0:\n print('total no. of raw data frames: {0}\\n'.format(len(file_list)))\n\n if skip_every is not None:\n print('Skipping every {0}-th frames per band\\n'.format(skip_every))\n\n else: #elif skip_every == None:\n '''\n bug: does not print even if skip_every is not entered in terminal\n '''\n print('Analyzing all raw frames per band')\n skip_every=1\n\n bands = {}\n for j in filters_in_config:\n j=j.strip(' ')\n bands[j]=[]\n filters_in_hdr=[]\n\n #get list of frames by filter based on header\n for i in tqdm(file_list[::skip_every]):\n hdr = pf.open(i)[0].header\n filters_in_hdr.append(hdr['FILTER'])\n for j in filters_in_config:\n if hdr['FILTER'] == j:\n j=j.strip(' ')\n bands[j].append(i)\n\n filters_in_hdr_set=list(set(filters_in_hdr)).sort()\n\n for k in bands.keys():\n print('{0}-band={1} frames'.format(k, len(bands[k])))\n #save into txtfile\n name = os.path.join(output_dir,k+'-band.txt')\n with open(name, 'w') as z: #overwrite\n #write line by line\n for line in bands[k]:\n z.write('{}\\n'.format(line))\n print('\\nfilenames sorted by band saved in {}'.format(output_dir))\n\n else:\n print('ERROR: check your data directory')\n #return empty dict\n bands={}\n\n return filters_in_hdr_set, bands","def load_config(self):\n pass","def update_configs(self, config):\n for what in self.plugins: # backend, repo etc.\n for key in self.plugins[what]: # s3, filesystem etc.\n # print(\"Updating configuration of\", what, key)\n self.plugins[what][key].config(what='set', params=config)\n return","def _process_config(self, config):\r\n \r\n # test for colors following the naming conventions of matplotlib\r\n for k, v in config['colors'].items():\r\n try:\r\n mcolors.CSS4_COLORS[v]\r\n except KeyError:\r\n print(\"Color stated for '%s' does not exist! \\\r\n Choose color from: '%s'\" % \r\n (k, list(mcolors.CSS4_COLORS.keys())))\r\n else:\r\n self.colors[k] = v\r\n \r\n self.image = config['image']\r\n self.font = config['font']\r\n self.milestones = config['milestones']\r\n self.labels = config['labels']","def apply_config(filename):\n with open(filename) as config_file:\n config = json.load(config_file)\n for setting, value in config.items():\n CoreConfig.__dict__[setting] = value","def main(args):\n\n with open(args.cfg_fn, 'r') as cfg_fd:\n config = cfg_fd.read().split(\"\\n\")\n\n with open(args.opt_fn, 'r') as opt_fd:\n for oline in opt_fd:\n option, value = oline.strip().split(\"=\")\n\n conf_addition = \"%s=%s\" % (option, value)\n added = False\n for line_nr, line in enumerate(config):\n if \"# %s is not set\" % option in line or \\\n \"%s=\" % option in line:\n config[line_nr] = conf_addition\n added = True\n break\n\n if not added:\n config.append(conf_addition)\n\n with open(args.cfg_fn, 'w') as cfg_fd:\n cfg_fd.write(\"\\n\".join(config))","def main(config):\n file_paths_info = [('GLOFRIS','WATCH','ARG_inunriver_historical_000000000WATCH_1980_rp01000.tif'),\n \t\t\t\t('GLOFRIS','RCP45','ARG_inunriver_rcp4p5_0000GFDL-ESM2M_2030_rp01000.tif'),\n \t\t\t\t('GLOFRIS','RCP85','ARG_inunriver_rcp8p5_0000GFDL-ESM2M_2030_rp01000.tif'),\n \t\t\t\t('FATHOM','AR_fluvial_undefended_merged','AR-FU-1000.tif'),\n \t\t\t\t('FATHOM','AR_pluvial_undefended_merged','AR-PU-1000.tif')\n \t\t\t\t]\n figure_names = ['GLOFRIS-WATCH-fluvial','GLOFRIS-RCP45-fluvial','GLOFRIS-RCP85-fluvial','FATHOM-fluvial','FATHOM-pluvial']\n figure_titles = ['current fluvial flooding','RCP4.5 fluvial flooding','RCP8.5 fluvial flooding','current fluvial flooding','current pluvial flooding']\n for f_i in range(len(file_paths_info)):\n\t hazard_file = os.path.join(config['paths']['data'],'flood_data', file_paths_info[f_i][0],file_paths_info[f_i][1],file_paths_info[f_i][2])\n\t output_file = os.path.join(config['paths']['figures'], 'flood-map-{}.png'.format(figure_names[f_i]))\n\t ax = get_axes()\n\t plot_basemap(ax, config['paths']['data'])\n\t scale_bar(ax, location=(0.8, 0.05))\n\t plot_basemap_labels(ax, config['paths']['data'], include_regions=True,include_zorder=3)\n\n\t proj_lat_lon = ccrs.PlateCarree()\n\n\n\t # Create color map\n\t colors = plt.get_cmap('Blues')\n\n\t # Read in raster data\n\t data, lat_lon_extent = get_data(hazard_file)\n\t data[(data <= 0) | (data > 5)] = np.nan\n\t max_val = np.nanmax(data)\n\t norm=mpl.colors.Normalize(vmin=0, vmax=max_val)\n\n\t # Plot population data\n\t im = ax.imshow(data, extent=lat_lon_extent,transform=proj_lat_lon, cmap=colors,norm =norm, zorder=2)\n\n\t # Add colorbar\n\t cbar = plt.colorbar(im, ax=ax,fraction=0.1, shrink=0.87,pad=0.01, drawedges=False, orientation='horizontal',\n\t norm=mpl.colors.Normalize(vmin=0, vmax=max_val), ticks=list(np.linspace(0,max_val,3)))\n\t cbar.set_clim(vmin=0,vmax=max_val)\n\n\n\t cbar.outline.set_color(\"none\")\n\t cbar.ax.yaxis.set_tick_params(color='black')\n\t cbar.ax.set_xlabel('Flood depths (m)',fontsize=12,color='black')\n\n\t plt.title('1 in 1000 year {}'.format(figure_titles[f_i]), fontsize = 14)\n\t save_fig(output_file)\n\t plt.close()","def main(configs, outfile='Linker.json', verbose=False):\n combined = {}\n\n for config in configs:\n with open(config) as fd:\n config_dict = json.load(fd)\n combined.update(config_dict)\n\n if verbose:\n print('\\n')\n print(json.dumps(combined, indent=4, sort_keys=True))\n\n if verbose:\n print('\\n')\n print('wrote new linker file: ' + outfile)\n json.dump(combined, open(outfile, 'w'), indent=4, sort_keys=True)","def main():\n processor.custom_config = parse_arguments()\n processor.process()\n logger.info(processor.statistics)\n logger.info(processor.custom_config)","def add_fixed_parameters_from_config_file(self, config_file):\n pass","def apply_settings():\n\n scs_globals = _get_scs_globals()\n\n # avoid recursion if another apply settings is running already\n if scs_globals.config_update_lock:\n return False\n\n # NOTE: save file paths in extra variables and apply them on the end\n # to make sure all of the settings are loaded first.\n # This is needed as some libraries reading are driven by other values from config file.\n # For example: \"use_infixed\"\n scs_project_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.scs_project_path, scs_globals)\n shader_presets_filepath = _property_utils.get_by_type(bpy.types.GlobalSCSProps.shader_presets_filepath, scs_globals)\n trigger_actions_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.trigger_actions_rel_path, scs_globals)\n sign_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.sign_library_rel_path, scs_globals)\n tsem_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.tsem_library_rel_path, scs_globals)\n traffic_rules_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.traffic_rules_library_rel_path, scs_globals)\n hookup_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.hookup_library_rel_path, scs_globals)\n matsubs_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.matsubs_library_rel_path, scs_globals)\n sun_profiles_library_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.sun_profiles_lib_path, scs_globals)\n conv_hlpr_converters_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.conv_hlpr_converters_path, scs_globals)\n\n # NOTE: as dump level is written in same section as config type\n # applying it directly might take place before we get information about config type\n # so it has to be saved into variable and applied only if global settings are loaded from config file\n dump_level = scs_globals.dump_level\n\n # lock update now, as we don't want any properties update functions to trigger rewrite of config file\n # which would lead to unwanted recursion\n engage_config_lock()\n\n config_container = _pix.get_data_from_file(get_config_filepath(), \" \")\n\n # avoid applying process of config if not present (most probably permission problems on config creation)\n if config_container is not None:\n\n settings_file_valid = 0\n for section in config_container:\n if settings_file_valid == 2:\n if section.type == \"Paths\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"ProjectPath\":\n scs_project_path = prop[1]\n elif prop[0] == \"ShaderPresetsFilePath\":\n shader_presets_filepath = prop[1]\n elif prop[0] == \"TriggerActionsRelFilePath\":\n trigger_actions_rel_path = prop[1]\n elif prop[0] == \"TriggerActionsUseInfixed\":\n scs_globals.trigger_actions_use_infixed = prop[1]\n elif prop[0] == \"SignRelFilePath\":\n sign_library_rel_path = prop[1]\n elif prop[0] == \"SignUseInfixed\":\n scs_globals.sign_library_use_infixed = prop[1]\n elif prop[0] == \"TSemProfileRelFilePath\":\n tsem_library_rel_path = prop[1]\n elif prop[0] == \"TSemProfileUseInfixed\":\n scs_globals.tsem_library_use_infixed = prop[1]\n elif prop[0] == \"TrafficRulesRelFilePath\":\n traffic_rules_library_rel_path = prop[1]\n elif prop[0] == \"TrafficRulesUseInfixed\":\n scs_globals.traffic_rules_library_use_infixed = prop[1]\n elif prop[0] == \"HookupRelDirPath\":\n hookup_library_rel_path = prop[1]\n elif prop[0] == \"MatSubsRelFilePath\":\n matsubs_library_rel_path = prop[1]\n elif prop[0] == \"SunProfilesFilePath\":\n sun_profiles_library_path = prop[1]\n elif prop[0] == \"ConvertersPath\":\n conv_hlpr_converters_path = prop[1]\n elif prop[0] == \"UseAlternativeBases\":\n scs_globals.use_alternative_bases = prop[1]\n else:\n lprint('W Unrecognised item \"%s\" has been found in setting file! Skipping...', (str(prop[0]),))\n elif section.type == \"Import\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"ImportScale\":\n scs_globals.import_scale = float(prop[1])\n elif prop[0] == \"PreservePathForExport\":\n scs_globals.import_preserve_path_for_export = prop[1]\n elif prop[0] == \"ImportPimFile\":\n scs_globals.import_pim_file = prop[1]\n elif prop[0] == \"UseWelding\":\n scs_globals.import_use_welding = prop[1]\n elif prop[0] == \"WeldingPrecision\":\n scs_globals.import_welding_precision = prop[1]\n elif prop[0] == \"UseNormals\":\n scs_globals.import_use_normals = prop[1]\n elif prop[0] == \"ImportPitFile\":\n scs_globals.import_pit_file = prop[1]\n elif prop[0] == \"LoadTextures\":\n scs_globals.import_load_textures = prop[1]\n elif prop[0] == \"ImportPicFile\":\n scs_globals.import_pic_file = prop[1]\n elif prop[0] == \"ImportPipFile\":\n scs_globals.import_pip_file = prop[1]\n elif prop[0] == \"ImportPisFile\":\n scs_globals.import_pis_file = prop[1]\n elif prop[0] == \"ConnectedBones\":\n scs_globals.import_connected_bones = prop[1]\n elif prop[0] == \"BoneImportScale\":\n scs_globals.import_bone_scale = float(prop[1])\n elif prop[0] == \"ImportPiaFile\":\n scs_globals.import_pia_file = prop[1]\n elif prop[0] == \"IncludeSubdirsForPia\":\n scs_globals.import_include_subdirs_for_pia = prop[1]\n elif section.type == \"Export\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"ExportScale\":\n scs_globals.export_scale = float(prop[1])\n elif prop[0] == \"ApplyModifiers\":\n scs_globals.export_apply_modifiers = prop[1]\n elif prop[0] == \"ExcludeEdgesplit\":\n scs_globals.export_exclude_edgesplit = prop[1]\n elif prop[0] == \"IncludeEdgesplit\":\n scs_globals.export_include_edgesplit = prop[1]\n elif prop[0] == \"ActiveUVOnly\":\n scs_globals.export_active_uv_only = prop[1]\n elif prop[0] == \"ExportVertexGroups\":\n scs_globals.export_vertex_groups = prop[1]\n elif prop[0] == \"ExportVertexColor\":\n scs_globals.export_vertex_color = prop[1]\n elif prop[0] == \"ExportVertexColorType\":\n scs_globals.export_vertex_color_type = str(prop[1])\n elif prop[0] == \"ExportVertexColorType7\":\n scs_globals.export_vertex_color_type_7 = str(prop[1])\n elif prop[0] == \"ExportPimFile\":\n scs_globals.export_pim_file = prop[1]\n elif prop[0] == \"OutputType\":\n scs_globals.export_output_type = prop[1]\n elif prop[0] == \"ExportPitFile\":\n scs_globals.export_pit_file = prop[1]\n elif prop[0] == \"ExportPicFile\":\n scs_globals.export_pic_file = prop[1]\n elif prop[0] == \"ExportPipFile\":\n scs_globals.export_pip_file = prop[1]\n elif prop[0] == \"SignExport\":\n scs_globals.export_write_signature = prop[1]\n elif section.type == \"GlobalDisplay\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"DisplayLocators\":\n scs_globals.display_locators = prop[1]\n elif prop[0] == \"LocatorSize\":\n scs_globals.locator_size = float(prop[1])\n elif prop[0] == \"LocatorEmptySize\":\n scs_globals.locator_empty_size = float(prop[1])\n elif prop[0] == \"DisplayConnections\":\n scs_globals.display_connections = prop[1]\n elif prop[0] == \"CurveSegments\":\n scs_globals.curve_segments = prop[1]\n elif prop[0] == \"OptimizedConnsDrawing\":\n scs_globals.optimized_connections_drawing = prop[1]\n elif prop[0] == \"DisplayTextInfo\":\n scs_globals.display_info = prop[1]\n else:\n lprint('W Unrecognised item \"%s\" has been found in setting file! Skipping...', (str(prop[0]),))\n elif section.type == \"GlobalColors\":\n for prop in section.props:\n if prop[0] in (\"\", \"#\"):\n pass\n elif prop[0] == \"PrefabLocatorsWire\":\n scs_globals.locator_prefab_wire_color = prop[1]\n elif prop[0] == \"ModelLocatorsWire\":\n scs_globals.locator_model_wire_color = prop[1]\n elif prop[0] == \"ColliderLocatorsWire\":\n scs_globals.locator_coll_wire_color = prop[1]\n elif prop[0] == \"ColliderLocatorsFace\":\n scs_globals.locator_coll_face_color = prop[1]\n elif prop[0] == \"NavigationCurveBase\":\n scs_globals.np_connection_base_color = prop[1]\n elif prop[0] == \"MapLineBase\":\n scs_globals.mp_connection_base_color = prop[1]\n elif prop[0] == \"TriggerLineBase\":\n scs_globals.tp_connection_base_color = prop[1]\n elif prop[0] == \"InfoText\":\n scs_globals.info_text_color = prop[1]\n elif prop[0] == \"BasePaint\":\n scs_globals.base_paint_color = prop[1]\n else:\n lprint('W Unrecognised item \"%s\" has been found in setting file! Skipping...', (str(prop[0]),))\n elif section.type == \"Header\":\n for prop in section.props:\n if prop[0] == \"FormatVersion\":\n if prop[1] == 1:\n settings_file_valid += 1\n elif prop[0] == \"Type\":\n if prop[1] == \"Configuration\":\n settings_file_valid += 1\n elif prop[0] == \"DumpLevel\":\n dump_level = prop[1]\n elif prop[0] == \"ConfigStoragePlace\":\n scs_globals.config_storage_place = prop[1]\n\n # if settings are read directly from blend file,\n # release update lock and don't search/apply any settings further\n if prop[1] == \"BlendFile\":\n settings_file_valid += 1\n\n # as dump level can be read already (it can be placed above config storage place property),\n # reset local variable back to value that was saved with blend file\n dump_level = scs_globals.dump_level\n\n break # to avoid further reading of header properties, so dump_level won't be overwritten unintentionally\n\n scs_globals.dump_level = dump_level\n\n # now as last apply all of the file paths\n # NOTE: applying paths is crucial for libraries\n # (they are reloaded/initiated in property update functions).\n if bpy.app.background: # if blender runs without UI then apply libraries directly as async operator is UI depended\n\n scs_globals.scs_project_path = scs_project_path\n scs_globals.shader_presets_filepath = shader_presets_filepath\n scs_globals.trigger_actions_rel_path = trigger_actions_rel_path\n scs_globals.sign_library_rel_path = sign_library_rel_path\n scs_globals.tsem_library_rel_path = tsem_library_rel_path\n scs_globals.traffic_rules_library_rel_path = traffic_rules_library_rel_path\n scs_globals.hookup_library_rel_path = hookup_library_rel_path\n scs_globals.matsubs_library_rel_path = matsubs_library_rel_path\n scs_globals.sun_profiles_lib_path = sun_profiles_library_path\n scs_globals.conv_hlpr_converters_path = conv_hlpr_converters_path\n\n else: # if blender is started normally use asynchronous operator to reload libraries\n\n bpy.ops.world.scs_paths_initialization('INVOKE_DEFAULT', paths_list=[\n {\"name\": \"project base path\", \"attr\": \"scs_project_path\", \"path\": scs_project_path},\n {\"name\": \"shader presets\", \"attr\": \"shader_presets_filepath\", \"path\": shader_presets_filepath},\n {\"name\": \"trigger actions library\", \"attr\": \"trigger_actions_rel_path\", \"path\": trigger_actions_rel_path},\n {\"name\": \"sign library\", \"attr\": \"sign_library_rel_path\", \"path\": sign_library_rel_path},\n {\"name\": \"traffic semaphore library\", \"attr\": \"tsem_library_rel_path\", \"path\": tsem_library_rel_path},\n {\"name\": \"traffic rules library\", \"attr\": \"traffic_rules_library_rel_path\", \"path\": traffic_rules_library_rel_path},\n {\"name\": \"hookups library\", \"attr\": \"hookup_library_rel_path\", \"path\": hookup_library_rel_path},\n {\"name\": \"material substance library\", \"attr\": \"matsubs_library_rel_path\", \"path\": matsubs_library_rel_path},\n {\"name\": \"sun profiles library\", \"attr\": \"sun_profiles_lib_path\", \"path\": sun_profiles_library_path},\n {\"name\": \"converters file path\", \"attr\": \"conv_hlpr_converters_path\", \"path\": conv_hlpr_converters_path},\n ])\n\n # release lock as properties are applied\n release_config_lock(use_paths_init_callback=not bpy.app.background)\n\n return True","def set_global_definitions(self):\n # TODO: Investigate how this could be combined with the creation of\n # self.configfiles in reffile_setup()\n\n self.global_subarray_definitions = {}\n self.global_readout_patterns = {}\n self.global_subarray_definition_files = {}\n self.global_readout_pattern_files = {}\n\n self.global_crosstalk_files = {}\n self.global_filtpupilcombo_files = {}\n self.global_filter_position_files = {}\n self.global_flux_cal_files = {}\n self.global_psf_wing_threshold_file = {}\n self.global_psfpath = {}\n # self.global_filter_throughput_files = {} ?\n\n for instrument in 'niriss fgs nircam miri nirspec'.split():\n if instrument.lower() == 'niriss':\n readout_pattern_file = 'niriss_readout_pattern.txt'\n subarray_def_file = 'niriss_subarrays.list'\n crosstalk_file = 'niriss_xtalk_zeros.txt'\n filtpupilcombo_file = 'niriss_dual_wheel_list.txt'\n filter_position_file = 'niriss_filter_and_pupil_wheel_positions.txt'\n flux_cal_file = 'niriss_zeropoints.list'\n psf_wing_threshold_file = 'niriss_psf_wing_rate_thresholds.txt'\n psfpath = os.path.join(self.datadir, 'niriss/gridded_psf_library')\n elif instrument.lower() == 'fgs':\n readout_pattern_file = 'guider_readout_pattern.txt'\n subarray_def_file = 'guider_subarrays.list'\n crosstalk_file = 'guider_xtalk_zeros.txt'\n filtpupilcombo_file = 'guider_filter_dummy.list'\n filter_position_file = 'dummy.txt'\n flux_cal_file = 'guider_zeropoints.list'\n psf_wing_threshold_file = 'fgs_psf_wing_rate_thresholds.txt'\n psfpath = os.path.join(self.datadir, 'fgs/gridded_psf_library')\n elif instrument.lower() == 'nircam':\n readout_pattern_file = 'nircam_read_pattern_definitions.list'\n subarray_def_file = 'NIRCam_subarray_definitions.list'\n crosstalk_file = 'xtalk20150303g0.errorcut.txt'\n filtpupilcombo_file = 'nircam_filter_pupil_pairings.list'\n filter_position_file = 'nircam_filter_and_pupil_wheel_positions.txt'\n flux_cal_file = 'NIRCam_zeropoints.list'\n psf_wing_threshold_file = 'nircam_psf_wing_rate_thresholds.txt'\n psfpath = os.path.join(self.datadir, 'nircam/gridded_psf_library')\n else:\n readout_pattern_file = 'N/A'\n subarray_def_file = 'N/A'\n crosstalk_file = 'N/A'\n filtpupilcombo_file = 'N/A'\n filter_position_file = 'N/A'\n flux_cal_file = 'N/A'\n psf_wing_threshold_file = 'N/A'\n psfpath = 'N/A'\n if instrument in 'niriss fgs nircam'.split():\n self.global_subarray_definitions[instrument] = self.get_subarray_defs(filename=os.path.join(self.modpath, 'config', subarray_def_file))\n self.global_readout_patterns[instrument] = self.get_readpattern_defs(filename=os.path.join(self.modpath, 'config', readout_pattern_file))\n self.global_subarray_definition_files[instrument] = os.path.join(self.modpath, 'config', subarray_def_file)\n self.global_readout_pattern_files[instrument] = os.path.join(self.modpath, 'config', readout_pattern_file)\n self.global_crosstalk_files[instrument] = os.path.join(self.modpath, 'config', crosstalk_file)\n self.global_filtpupilcombo_files[instrument] = os.path.join(self.modpath, 'config', filtpupilcombo_file)\n self.global_filter_position_files[instrument] = os.path.join(self.modpath, 'config', filter_position_file)\n self.global_flux_cal_files[instrument] = os.path.join(self.modpath, 'config', flux_cal_file)\n self.global_psf_wing_threshold_file[instrument] = os.path.join(self.modpath, 'config', psf_wing_threshold_file)\n self.global_psfpath[instrument] = psfpath","def test_filters_with_extra_extraction(self) -> None:\n\n # pylint: disable=too-many-locals\n\n import hammer_config\n\n tech_dir, tech_dir_base = HammerToolTestHelpers.create_tech_dir(\"dummy28\")\n tech_json_filename = os.path.join(tech_dir, \"dummy28.tech.json\")\n\n def add_named_library(in_dict: Dict[str, Any]) -> Dict[str, Any]:\n out_dict = deepdict(in_dict)\n out_dict[\"libraries\"].append({\n \"name\": \"abcdef\",\n \"milkyway techfile\": \"test/abcdef.tf\"\n })\n return out_dict\n\n HammerToolTestHelpers.write_tech_json(tech_json_filename, add_named_library)\n sys.path.append(tech_dir_base)\n tech = self.get_tech(hammer_tech.HammerTechnology.load_from_dir(\"dummy28\", tech_dir))\n tech.cache_dir = tech_dir\n\n def filter_func(lib: hammer_tech.Library) -> bool:\n return lib.milkyway_techfile is not None\n\n def paths_func(lib: hammer_tech.Library) -> List[str]:\n assert lib.milkyway_techfile is not None\n return [lib.milkyway_techfile]\n\n def extraction_func(lib: hammer_tech.Library, paths: List[str]) -> List[str]:\n assert len(paths) == 1\n if lib.name is None:\n name = \"\"\n else:\n name = str(lib.name)\n return [json.dumps({\"path\": paths[0], \"name\": name}, cls=HammerJSONEncoder, indent=4)]\n\n def sort_func(lib: hammer_tech.Library):\n assert lib.milkyway_techfile is not None\n return lib.milkyway_techfile\n\n test_filter = LibraryFilter.new(\"metatest\", \"Test filter that extracts metadata\",\n is_file=True, filter_func=filter_func,\n paths_func=paths_func,\n extraction_func=extraction_func,\n sort_func=sort_func)\n\n database = hammer_config.HammerDatabase()\n tech.set_database(database)\n raw = tech.process_library_filter(pre_filts=[], filt=test_filter,\n must_exist=False,\n output_func=hammer_tech.HammerTechnologyUtils.to_plain_item)\n\n # Disable false positive from pylint\n outputs = list(map(lambda s: json.loads(s), raw)) # pylint: disable=unnecessary-lambda\n self.assertEqual(outputs,\n [\n {\"path\": tech.prepend_dir_path(\"test/abcdef.tf\"), \"name\": \"abcdef\"},\n {\"path\": tech.prepend_dir_path(\"test/coconut\"), \"name\": \"\"},\n {\"path\": tech.prepend_dir_path(\"test/soy\"), \"name\": \"\"}\n ])\n\n # Cleanup\n shutil.rmtree(tech_dir_base)","def __writeConfig(self):\n page = None\n\n #TODO: get values of configurations here\n particles = \"#f\" if not base.particleMgrEnabled else \"#t\"\n volume = str(round(base.musicManager.getVolume(), 2))\n mute = \"#f\" if base.AppHasAudioFocus else \"#t\"\n #TODO: add any configuration variable name that you have added\n customConfigVariables = [\n \"\", \"particles-enabled\", \"audio-mute\", \"audio-volume\"]\n if os.path.exists(prcFile):\n # open the config file and change values according to current\n # application settings\n page = loadPrcFile(Filename.fromOsSpecific(prcFile))\n removeDecls = []\n for dec in range(page.getNumDeclarations()):\n # Check if our variables are given.\n # NOTE: This check has to be done to not loose our base or other\n # manual config changes by the user\n if page.getVariableName(dec) in customConfigVariables:\n decl = page.modifyDeclaration(dec)\n removeDecls.append(decl)\n for dec in removeDecls:\n page.deleteDeclaration(dec)\n # NOTE: particles-enabled and audio-mute are custom variables and\n # have to be loaded by hand at startup\n # Particles\n page.makeDeclaration(\"particles-enabled\", particles)\n # audio\n page.makeDeclaration(\"audio-volume\", volume)\n page.makeDeclaration(\"audio-mute\", mute)\n else:\n # Create a config file and set default values\n cpMgr = ConfigPageManager.getGlobalPtr()\n page = cpMgr.makeExplicitPage(\"%s Pandaconfig\"%appName)\n # set OpenGL to be the default\n page.makeDeclaration(\"load-display\", \"pandagl\")\n # get the displays width and height\n w = self.pipe.getDisplayWidth()\n h = self.pipe.getDisplayHeight()\n # set the window size in the config file\n page.makeDeclaration(\"win-size\", \"%d %d\"%(w, h))\n # set the default to fullscreen in the config file\n page.makeDeclaration(\"fullscreen\", \"1\")\n # particles\n page.makeDeclaration(\"particles-enabled\", \"#t\")\n # audio\n page.makeDeclaration(\"audio-volume\", volume)\n page.makeDeclaration(\"audio-mute\", \"#f\")\n # create a stream to the specified config file\n configfile = OFileStream(prcFile)\n # and now write it out\n page.write(configfile)\n # close the stream\n configfile.close()","def _initConfig(self):\n from tg import config as tg_config\n\n # Set config defaults\n config = DEFAULT_CONFIG.copy()\n temp_verbose = config[\"verbose\"]\n\n # Configuration file overrides defaults\n default_config_file = os.path.abspath(DEFAULT_CONFIG_FILE)\n config_file = tg_config.get('wsgidav.config_path', default_config_file)\n fileConf = self._readConfigFile(config_file, temp_verbose)\n config.update(fileConf)\n\n if not useLxml and config[\"verbose\"] >= 1:\n print(\n \"WARNING: Could not import lxml: using xml instead (slower). Consider installing lxml from http://codespeak.net/lxml/.\")\n from wsgidav.dir_browser import WsgiDavDirBrowser\n from tracim.lib.webdav.tracim_http_authenticator import TracimHTTPAuthenticator\n from wsgidav.error_printer import ErrorPrinter\n from tracim.lib.webdav.utils import TracimWsgiDavDebugFilter\n\n config['middleware_stack'] = [\n WsgiDavDirBrowser,\n TracimHTTPAuthenticator,\n ErrorPrinter,\n TracimWsgiDavDebugFilter,\n ]\n\n config['provider_mapping'] = {\n config['root_path']: Provider(\n # TODO: Test to Re enabme archived and deleted\n show_archived=False, # config['show_archived'],\n show_deleted=False, # config['show_deleted'],\n show_history=False, # config['show_history'],\n manage_locks=config['manager_locks']\n )\n }\n\n config['domaincontroller'] = TracimDomainController(presetdomain=None, presetserver=None)\n\n return config","def main(parfile,verbose):\n level = args.verbose.lower()\n levels = { \"debug\": logging.DEBUG, \"info\": logging.INFO,\n \"warn\": logging.WARNING,\n \"warning\": logging.WARNING, \"error\": logging.ERROR }\n if not level in levels:\n logger.error ( \"Unknown log level ``%s'' supplied!\" % level )\n sys.exit()\n logger.setLevel(level = levels[level])\n\n parser = ConfigParserExt()\n ret = parser.read(parfile)\n if ret == []:\n logger.error( \"No such file or directory: '%s'\" % parfile)\n sys.exit()\n\n if not parser.has_option('options', 'input'):\n logger.error(\"An input file or folder must be defined.\")\n sys.exit()\n else:\n inputF = parser.get('options','input')\n if os.path.isfile(inputF):\n inputFiles = [os.path.abspath(inputF)]\n elif \"*\" in inputF:\n inputFiles = [os.path.abspath(f) for f in glob.glob(inputF)]\n elif os.path.isdir(inputF):\n inputFiles = [os.path.abspath(os.path.join(inputF,f))\n for f in os.listdir(inputF)\n if os.path.isfile(os.path.join(inputF, f))]\n else:\n logger.error(\"Input format %s not accepted\" %inputF)\n sys.exit()\n\n parserList = []\n for f in inputFiles:\n newParser = ConfigParserExt()\n newParser.read_dict(parser.toDict(raw=True))\n newParser.set(\"CheckMateParameters\",\"SLHAFile\",f)\n newParser.set(\"CheckMateParameters\",\"Name\",\n os.path.splitext(os.path.basename(f))[0])\n newParser.set(\"CheckMateParameters\",\"OutputDirectory\",\n os.path.abspath(parser.get(\"CheckMateParameters\",\"OutputDirectory\")))\n #Get tags of processes:\n processTags = [tag for tag in newParser.sections()\n if (tag.lower() != 'options' and tag.lower() != 'checkmateparameters')]\n\n #Get xsec dictionary:\n useSLHA = False\n unit = 'PB'\n xsecDict = {}\n if newParser.has_option(\"options\",\"xsecUnit\"):\n unit = newParser.get(\"options\",\"xsecUnit\")\n if newParser.has_option(\"options\",\"useSLHAxsecs\"):\n useSLHA = newParser.get(\"options\",\"useSLHAxsecs\")\n if not isinstance(useSLHA,dict):\n logger.error(\"useSLHAxsecs should be defined as dictionary with a key for each CheckMate process.\")\n sys.exit()\n\n xsecsAll = pyslha.readSLHAFile(f).xsections\n for pTag,xsecTuple in useSLHA.items():\n if not xsecTuple in xsecsAll: continue\n xsecs = xsecsAll[xsecTuple].xsecs\n xsecs = sorted(xsecs, key = lambda xsec: xsec.qcd_order,\n reverse=True)\n xsecDict[pTag] = xsecs[0]\n\n for pTag in processTags:\n pName = newParser.get(pTag,\"Name\")\n newParser.set(pTag,\"MGparam\",f)\n if useSLHA:\n if pTag in xsecDict:\n newParser.set(pTag,\"XSect\", \"%1.5g %s\" %(xsecDict[pTag].value,unit))\n if pName in xsecDict:\n newParser.set(pTag,\"XSect\", \"%1.5g %s\" %(xsecDict[pName].value,unit))\n\n parserList.append(newParser)\n\n ncpus = int(parser.get(\"options\",\"ncpu\"))\n if ncpus < 0:\n ncpus = multiprocessing.cpu_count()\n ncpus = min(ncpus,len(parserList))\n pool = multiprocessing.Pool(processes=ncpus)\n children = []\n #Loop over parsers and submit jobs\n logger.info(\"Submitting %i jobs over %i cores\" %(len(parserList),ncpus))\n for newParser in parserList:\n logger.debug(\"Submitting job for file %s\"\n %(newParser.get(\"CheckMateParameters\",\"SLHAFile\")))\n parserDict = newParser.toDict(raw=False) #Must convert to dictionary for pickling\n p = pool.apply_async(RunCheckMate, args=(parserDict,))\n children.append(p)\n time.sleep(10)\n\n\n #Wait for jobs to finish:\n output = [p.get() for p in children]\n for out in output:\n print(out)","def configuration_presets(configuration):\n\n # pylint: disable=too-many-branches\n # pylint: disable=too-many-statements\n\n # Save the #defines\n define_list = []\n\n # If not None, add in _DEBUG or NDEBUG\n if configuration.debug is not None:\n define_list.append(\"_DEBUG\" if configuration.debug else \"NDEBUG\")\n\n # Init the list of libraries to load\n libraries_list = []\n\n # Sanity check for missing platform\n platform = configuration.platform\n if platform is not None:\n\n ide = configuration.project.ide\n\n # Force a test for the WATCOM environment variable\n # for Watcom for Windows or DOS\n if ide is IDETypes.watcom:\n if platform.is_windows() or platform.is_msdos():\n configuration.env_variable_list = [\"WATCOM\"]\n\n # Windows specific defines\n if platform.is_windows():\n\n if ide.is_codewarrior():\n configuration.library_folders_list = [\n \"$(CodeWarrior)/MSL\", \"$(CodeWarrior)/Win32-x86 Support\"]\n if configuration.debug:\n libraries_list.append(\"MSL_All_x86_D.lib\")\n else:\n libraries_list.append(\"MSL_All_x86.lib\")\n\n libraries_list.extend(\n [\"Kernel32.lib\", \"Gdi32.lib\", \"Shell32.lib\", \"Ole32.lib\",\n \"User32.lib\", \"Advapi32.lib\", \"version.lib\", \"Ws2_32.lib\",\n \"Comctl32.lib\", \"WinMM.lib\"])\n\n define_list.extend([\"_WINDOWS\", \"WIN32_LEAN_AND_MEAN\"])\n if platform in (PlatformTypes.win64,\n PlatformTypes.winarm64, PlatformTypes.winitanium):\n define_list.append(\"WIN64\")\n else:\n define_list.append(\"WIN32\")\n\n # Command line tools need this define\n if configuration.project_type is ProjectTypes.tool:\n define_list.append(\"_CONSOLE\")\n\n # MSDos with DOS4GW extender\n if platform is PlatformTypes.msdos4gw:\n define_list.append(\"__DOS4G__\")\n\n # MSDos with X32 extender\n if platform is PlatformTypes.msdosx32:\n define_list.append(\"__X32__\")\n\n # Playstation 4\n if platform is PlatformTypes.ps4:\n define_list.append(\"__ORBIS2__\")\n\n # Include default libraries\n libraries_list.extend((\n \"SceSysmodule_stub_weak\",\n \"ScePosix_stub_weak\",\n \"SceVideoOut_stub_weak\",\n \"ScePad_stub_weak\",\n \"SceVideodec2_stub_weak\",\n \"SceAudiodec_stub_weak\",\n \"SceAudioOut_stub_weak\",\n \"SceGnmDriver_stub_weak\",\n \"SceGnm\",\n \"SceGnmx\",\n \"SceGpuAddress\"))\n\n # Playstation 5 (Not needed)\n # if platform is PlatformTypes.ps5:\n # define_list.append(\"__PROSPERO__\")\n\n # Playstation Vita\n if platform is PlatformTypes.vita:\n define_list.append(\"SN_TARGET_PSP2\")\n\n # Google Stadia\n if platform is PlatformTypes.stadia:\n define_list.append(\"_GNU_SOURCE\")\n define_list.append(\"VK_USE_PLATFORM_GGP\")\n\n # Android targets\n if platform.is_android():\n define_list.append(\"DISABLE_IMPORTGL\")\n libraries_list.extend([\"android\", \"EGL\", \"GLESv1_CM\"])\n\n # Xbox 360\n if platform is PlatformTypes.xbox360:\n define_list.extend([\"_XBOX\", \"XBOX\"])\n libraries_list.extend([\"xbdm.lib\", \"xboxkrnl.lib\"])\n if configuration.get_chained_value(\"profile\"):\n libraries_list.extend(\n [\"d3d9i.lib\", \"d3dx9i.lib\", \"xgraphics.lib\", \"xapilibi.lib\",\n \"xaudio2.lib\", \"x3daudioi.lib\", \"xmcorei.lib\"])\n elif configuration.debug:\n libraries_list.extend(\n [\"d3d9d.lib\", \"d3dx9d.lib\", \"xgraphicsd.lib\",\n \"xapilibd.lib\", \"xaudiod2.lib\", \"x3daudiod.lib\",\n \"xmcored.lib\"])\n else:\n libraries_list.extend(\n [\"d3d9ltcg.lib\", \"d3dx9.lib\", \"xgraphics.lib\",\n \"xapilib.lib\", \"xaudio2.lib\", \"x3daudioltcg.lib\",\n \"xmcoreltcg.lib\"])\n\n # Xbox ONE\n if platform is PlatformTypes.xboxone:\n libraries_list.extend(\n [\"pixEvt.lib\", \"d3d11_x.lib\", \"combase.lib\", \"kernelx.lib\",\n \"uuid.lib\", \"%(XboxExtensionsDependencies)\"])\n\n # Nintendo DSI specific defines\n if platform is PlatformTypes.dsi:\n define_list.extend([\n \"NN_BUILD_DEBUG\",\n \"NN_COMPILER_RVCT\",\n \"NN_COMPILER_RVCT_VERSION_MAJOR=$(CTRSDK_RVCT_VER_MAJOR)\",\n \"NN_PROCESSOR_ARM\",\n \"NN_PROCESSOR_ARM11MPCORE\",\n \"NN_PROCESSOR_ARM_V6\",\n \"NN_PROCESSOR_ARM_VFP_V2\",\n \"NN_HARDWARE_CTR\",\n \"NN_PLATFORM_CTR\",\n \"NN_HARDWARE_CTR_TS\",\n \"NN_SYSTEM_PROCESS\",\n \"NN_SWITCH_ENABLE_HOST_IO=1\",\n \"NN_BUILD_VERBOSE\",\n \"NN_BUILD_NOOPT\",\n \"NN_DEBUGGER_KMC_PARTNER\"])\n\n # Nintendo WiiU\n if platform is PlatformTypes.wiiu:\n configuration.include_folders_list.append(\n \"$(CAFE_ROOT_DOS)\\\\system\\\\src\\\\tool\\\\gfx\\\\include\")\n configuration.include_folders_list.append(\n \"$(CAFE_ROOT_DOS)\\\\system\\\\include\")\n\n # Nintendo Switch\n if platform.is_switch():\n configuration.include_folders_list.append(\n \"$(NINTENDO_SDK_ROOT)\\\\include\")\n\n if platform is PlatformTypes.switch32:\n configuration.include_folders_list.append(\n \"$(NINTENDO_SDK_ROOT)\\\\TargetSpecificInclude\\\\\"\n \"NX-NXFP2-a32\")\n else:\n configuration.include_folders_list.append(\n \"$(NINTENDO_SDK_ROOT)\\\\TargetSpecificInclude\\\\\"\n \"NX-NXFP2-a64\")\n\n define_list.append(\"NN_NINTENDO_SDK\")\n if configuration.debug:\n define_list.append(\"NN_ENABLE_ASSERT\")\n define_list.append(\"NN_ENABLE_ABORT_MESSAGE\")\n if configuration.optimization:\n define_list.append(\"NN_SDK_BUILD_DEVELOP\")\n else:\n define_list.append(\"NN_SDK_BUILD_DEBUG\")\n else:\n define_list.append(\"NN_SDK_BUILD_RELEASE\")\n define_list.append(\"NN_DISABLE_ASSERT\")\n define_list.append(\"NN_DISABLE_ABORT_MESSAGE\")\n\n # Linux platform\n if platform is PlatformTypes.linux:\n define_list.append(\"__LINUX__\")\n\n # Mac Carbon\n if platform.is_macos_carbon():\n define_list.append(\"TARGET_API_MAC_CARBON=1\")\n\n # macOS X platform frameworks\n if platform.is_macosx():\n if not configuration.project_type.is_library():\n configuration.frameworks_list = [\n \"AppKit.framework\", \"AudioToolbox.framework\",\n \"AudioUnit.framework\", \"Carbon.framework\",\n \"Cocoa.framework\", \"CoreAudio.framework\",\n \"IOKit.framework\", \"OpenGL.framework\",\n \"QuartzCore.framework\", \"SystemConfiguration.framework\"\n ]\n\n # iOS platform frameworks\n if platform.is_ios():\n if not configuration.project_type.is_library():\n configuration.frameworks_list = [\n \"AVFoundation.framework\", \"CoreGraphics.framework\",\n \"CoreLocation.framework\", \"Foundation.framework\",\n \"QuartzCore.framework\", \"UIKit.framework\"\n ]\n\n # Save the macros\n configuration.define_list = define_list\n\n # Only link libraries for executables.\n project_type = configuration.project_type\n if project_type is not None:\n if not project_type.is_library():\n configuration.libraries_list = libraries_list","def parse_config(self):\n # TODO: parse config file\n pass","def load(cls, filenames, config_factory=Config):\n return cls([config_factory(f, label=label) for label, f in filenames])","def apply_config(self, config_path: str) -> None:\n # pylint: disable=exec-used\n try:\n assert self._active_feature_set is None\n type(self)._active_feature_set = self\n\n # Apply both src and dist spinoff configs.\n exec_context: dict = {}\n with open(config_path, encoding='utf-8') as infile:\n config_contents = infile.read()\n\n # Use compile here so we can provide a nice file path for\n # error tracebacks.\n exec(\n compile(config_contents, config_path, 'exec'),\n exec_context,\n exec_context,\n )\n\n finally:\n assert type(self)._active_feature_set is self\n type(self)._active_feature_set = None","def update_config(self):\n if self.integration is None:\n return\n self.enabled = self.integration.has_option(self.get_config_name())\n self.pedantic = self.integration.configuration.get_bool(\n 'filter.mrproper')","def __init__(self):\n ConfigParser.RawConfigParser.OPTCRE = re.compile(r'(?P<option>[^=\\s][^=]*)\\s*(?P<vi>[=])\\s*(?P<value>.*)$')\n self.CONFIG = ConfigParser.ConfigParser()\n self.CONFIG.read(os.path.join(os.path.dirname(__file__)))\n self.IPS = []"],"string":"[\n \"def initFilters(CONFIG):\\n\\t#### String containing all the preLibraries file name\\n\\tpreLibraries = findFile(\\\"classification_result/prelibraries/TE\\\", \\\"*.fasta\\\")\\n\\n\\t#### String containing all the preLibraries file name\\n\\tnoCatLibrarie = findFile(\\\"classification_result/prelibraries/\\\", \\\"noCat.fasta\\\")\\n\\n\\tlistPrelibraries = []\\n\\t#### dictionnaries that will contains all the id's sequences for concerned libraries\\n\\tdicoLibraries={\\\"autonomousLib\\\":[], \\\"totalTELib\\\":[], \\\"totalRepeatLib\\\":[]}\\n\\n\\tlistPrelibraries.append(noCatLibrarie[0])\\n\\t#### Add all the name of prelibraries in listPrelibraries\\n\\tfor file in preLibraries:\\n\\t\\tlistPrelibraries.append(file)\\n\\n\\t#### Dictionnary that restain the final classification for a given sequence (helpfull for the intermediateLibraries)\\n\\tdicoFinalClassif={}\\n\\t#### Parse all the prelibrary\\n\\tprint(\\\"####\\tApply the filters to create the intermediate libraries\\\")\\n\\tcreateIntermediateLibraries(listPrelibraries, dicoLibraries, CONFIG, dicoFinalClassif)\\n\\n\\t#### List containing all the intermediate librarie file name\\n\\tintermediateLibraries = findFile(\\\"classification_result/intermediateLibraries\\\", \\\"*.fasta\\\")\\n\\n\\tprint(\\\"####\\tApply the cd-hit-est on the intermediate libraries\\\")\\n\\tapplyCDHIT(intermediateLibraries)\\n\\n\\tretriveFinalLibrarieSequences(intermediateLibraries, CONFIG, dicoFinalClassif, dicoLibraries)\\n\\n\\tprint(\\\"####\\tCreation of the three final libraries\\\")\\n\\tcreateFinalLibraries(intermediateLibraries, dicoLibraries)\\n\\n\\tprint(\\\"Number of sequences in autonomousTE : {nbAutonomous}\\\\nNumber of sequences in totalTE : {nbTotalTE}\\\\nNumber of sequences in totalRepeatLib : {nbRepeated}\\\".format(\\\\\\n\\tnbAutonomous=len(dicoLibraries[\\\"autonomousLib\\\"]), nbTotalTE=len(dicoLibraries[\\\"totalTELib\\\"]), nbRepeated=len(dicoLibraries[\\\"totalRepeatLib\\\"])))\",\n \"def build_configs():\",\n \"def __init__ (self, config_yaml):\\n configdef = yaml.safe_load(io.StringIO(config_yaml)) \\n\\n if \\\"filters\\\" not in configdef:\\n configdef = dict(filters=[configdef])\\n\\n self._configs = []\\n\\n for definition in configdef[\\\"filters\\\"]:\\n config = Bunch( valid_from = None\\n , volume_follows = False\\n , copy_last_price = False\\n , copy_last_volume = False\\n , qualifier_include_filters = []\\n , qualifier_exclude_filters = []\\n , exclude_filters = [] )\\n\\n if \\\"filter\\\" in definition and definition[\\\"filter\\\"] != None:\\n for exclude_filter in definition[\\\"filter\\\"]:\\n parts = exclude_filter.split(\\\",\\\")\\n if parts[0] == \\\"floor\\\":\\n config.exclude_filters.append(FloorFilter(float(parts[1]), \\\"price\\\"))\\n elif parts[0] == \\\"cap\\\":\\n config.exclude_filters.append(CapFilter(float(parts[1]), \\\"price\\\")) \\n elif parts[0] == \\\"step\\\":\\n config.exclude_filters.append(StepFilter(int(parts[1]), float(parts[2]), float(parts[3]), \\\"price\\\"))\\n else:\\n raise Exception(\\\"Unknown filter (%s)\\\" % (parts[0])) \\n \\n if \\\"remove\\\" in definition and definition[\\\"remove\\\"] != None:\\n for exclude_filter in definition[\\\"remove\\\"]:\\n config.qualifier_exclude_filters.append(QualifierFilter(exclude_filter))\\n \\n if \\\"allow\\\" in definition and definition[\\\"allow\\\"] != None:\\n for include_filter in definition[\\\"allow\\\"]:\\n config.qualifier_include_filters.append(QualifierFilter(include_filter))\\n\\n if \\\"volFollows\\\" in definition: config.volume_follows = definition[\\\"volFollows\\\"] \\n if \\\"copyLast\\\" in definition and definition[\\\"copyLast\\\"] != None:\\n config.copy_last_price = definition[\\\"copyLast\\\"] \\n config.copy_last_volume = definition[\\\"copyLast\\\"] \\n if \\\"volumeLimit\\\" in definition and definition[\\\"volumeLimit\\\"] != None:\\n config.exclude_filters.append(CapFilter(definition[\\\"volumeLimit\\\"], \\\"volume\\\"))\\n if \\\"validFrom\\\" in definition and definition[\\\"validFrom\\\"] != None:\\n valid_from = datetime.datetime.strptime(definition[\\\"validFrom\\\"], \\\"%Y-%m-%d %H:%M:%S\\\")\\n valid_from.replace(tzinfo=pytz.utc)\\n config.valid_from = common.Time.tick(valid_from)\\n if \\\"weekTimezone\\\" in definition and definition[\\\"weekTimezone\\\"] != None:\\n config.exclude_filters.append(WeekendFilter(definition[\\\"weekTimezone\\\"], definition[\\\"weekEnd\\\"], definition[\\\"weekStart\\\"]))\\n\\n self._configs.append(config)\\n \\n self._config_index = 0\\n self._config_count = len(self._configs)\",\n \"def build(config):\",\n \"def load_filter(filename):\\n # parse config file\\n if not os.path.isfile(filename):\\n raise IOError('File \\\"%s\\\" does not exist' % filename)\\n try:\\n f = open(filename)\\n except IOError:\\n raise IOError('Could not open file \\\"%s\\\"' % filename)\\n\\n cfg_items = []\\n for (i, line) in enumerate(f):\\n try:\\n # remove all comments and unnecessary whitespace\\n normalizer = shlex.shlex(line)\\n normalizer.wordchars += '.-'\\n normal_line = ' '.join([t for t in normalizer])\\n if normal_line:\\n # split up normalized line and build dictionary\\n cfg_item = {}\\n for part in normal_line.split(','):\\n cfg_split = shlex.split(part)\\n key = cfg_split.pop(0)\\n value = cfg_split\\n cfg_item[key] = value\\n cfg_items.append(cfg_item)\\n except (IndexError, ValueError):\\n raise RuntimeError( \\\\\\n 'Could not parse line %i of file \\\"%s\\\"' % (i, filename))\\n\\n # look for global bit settings\\n bits_global = None\\n factor_bits_global = None\\n norm_bits_global = None\\n for cfg_item in cfg_items:\\n if 'bits_global' in cfg_item:\\n if bits_global is None:\\n [bits_global] = cfg_item.pop('bits_global')\\n bits_global = int(bits_global)\\n else:\\n raise RuntimeError( \\\\\\n 'bits_global must not be specified more than once')\\n if 'factor_bits_global' in cfg_item:\\n if factor_bits_global is None:\\n [factor_bits_global] = cfg_item.pop('factor_bits_global')\\n factor_bits_global = int(factor_bits_global)\\n else:\\n raise RuntimeError( \\\\\\n 'factor_bits_global must not be specified more than once')\\n if 'norm_bits_global' in cfg_item:\\n if norm_bits_global is None:\\n [norm_bits_global] = cfg_item.pop('norm_bits_global')\\n norm_bits_global = int(norm_bits_global)\\n else:\\n raise RuntimeError( \\\\\\n 'norm_bits_global must not be specified more than once')\\n\\n # remove empty items from cfg_items, only node definitions should be left\\n cfg_items = filter(None, cfg_items)\\n\\n # look for filter nodes\\n filter_nodes = {}\\n adjacency = {}\\n input_node = None\\n output_node = None\\n for cfg_item in cfg_items:\\n # mandatory settings\\n try:\\n [node] = cfg_item['node']\\n except KeyError:\\n raise RuntimeError('Node type not specified')\\n try:\\n [name] = cfg_item['name']\\n except KeyError:\\n raise RuntimeError('Name not specified')\\n # optional settings\\n if 'bits' in cfg_item:\\n [bits] = map(int, cfg_item['bits'])\\n else:\\n bits = bits_global\\n if 'connect' in cfg_item:\\n connect = cfg_item['connect']\\n else:\\n connect = []\\n if 'input' in cfg_item:\\n if input_node is None:\\n input_node = name\\n else:\\n raise RuntimeError('More than one input node specified')\\n if 'output' in cfg_item:\\n if output_node is None:\\n output_node = name\\n else:\\n raise RuntimeError('More than one output node specified')\\n\\n # make filter node\\n if name not in filter_nodes:\\n if bits is not None:\\n if node == 'Const':\\n filter_nodes[name] = Const(bits)\\n elif node == 'Add':\\n filter_nodes[name] = Add(bits)\\n elif node == 'Delay':\\n filter_nodes[name] = Delay(bits)\\n elif node == 'Multiply':\\n if 'factor_bits' in cfg_item:\\n [factor_bits] = cfg_item['factor_bits']\\n factor_bits = int(factor_bits)\\n else:\\n factor_bits = factor_bits_global\\n if 'norm_bits' in cfg_item:\\n [norm_bits] = cfg_item['norm_bits']\\n norm_bits = int(norm_bits)\\n else:\\n norm_bits = norm_bits_global\\n if (factor_bits is not None and norm_bits is not None):\\n filter_nodes[name] = Multiply(\\n bits, factor_bits, norm_bits)\\n if 'factor' in cfg_item:\\n [factor] = cfg_item['factor']\\n factor = float(factor)\\n filter_nodes[name].set_factor(factor, norm=True)\\n else:\\n raise ValueError('Unknown node type: %s' % node)\\n else:\\n raise RuntimeError('Number of bits for node \\\"%s\\\" not specified' \\\\\\n % name)\\n adjacency[name] = connect\\n else:\\n raise RuntimeError('Node \\\"%s\\\" already present' % name)\\n\\n # make filter\\n if input_node is None:\\n raise RuntimeError('No input node specified')\\n elif output_node is None:\\n raise RuntimeError('No output node specified')\\n else:\\n return Filter(filter_nodes, adjacency, input_node, output_node)\",\n \"def __load_config_files(self):\\n # Parsed configuration files\\n # ==========================\\n T_dict = ParsedParameterFile(self.config_path('0/T'))\\n fv_solutions = ParsedParameterFile(self.config_path('system/fvSolution'))\\n fv_schemes = ParsedParameterFile(self.config_path('system/fvSchemes'))\\n control_dict = ParsedParameterFile(self.config_path('system/controlDict'))\\n transport_props = ParsedParameterFile(self.config_path('constant/transportProperties'))\\n\\n # Registered files\\n # ================\\n self.foam_file('0/T', T_dict)\\n self.foam_file('system/controlDict', control_dict)\\n self.foam_file('system/fvSolution', fv_solutions)\\n self.foam_file('system/fvSchemes', fv_schemes)\\n self.foam_file('system/controlDict', control_dict)\\n self.foam_file('constant/transportProperties', transport_props)\",\n \"def process_config(self, filename):\\n \\n self.log_message(\\\"processing config file: \\\"+filename)\\n parser = SafeConfigParser()\\n parser.optionxform = str\\n parser.read(filename)\\n self.source_files[filename] = parser\\n \\n sections = parser.sections()\\n for section in sections:\\n \\n options = parser.options(section)\\n params = {}\\n non_std = {}\\n for option in options:\\n ## any option that ends with the word \\\"password\\\" will be encrypted and will automatically be decrypted upon\\n ## processing \\n if option in self.standard_options:\\n params[option] = self.get_value(option, parser.get(section, option))\\n else:\\n non_std[option] = self.get_value(option, parser.get(section, option))\\n\\n params['non_std'] = non_std\\n params['source_file'] = filename\\n params['name']=section\\n params['run_date']=self.run_date\\n c_entry = ConfigEntry(params)\\n if c_entry.ready: \\n entry_num = c_entry.get_entry_type()\\n self.entries[self.entry_types[entry_num]].append(c_entry)\\n self.entry_dict[section] = {'source':filename,'entry':c_entry}\\n self.log_message(\\\"Loaded Config Entry: \\\"+section)\\n else:\\n self.log_message(\\\"Failed to load config entry: \\\"+section)\\n\\n return self.entries\",\n \"def _augment_pipeline_cfg(self):\",\n \"def main(config):\\n current_config = DKRConfig()\\n\\n for key, value in config.items():\\n\\n if key in current_config.config:\\n for version in value['versions']:\\n current_config.add_entrypoint_version(key, version)\\n continue\\n\\n current_config.add_entrypoint(key, value['versions'])\\n\\n current_config.write(create=True)\",\n \"def _setup_pipeline_cfg(self):\",\n \"def get_configs(self, configs):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\tcp = LayerConfigParser()\\n\\t\\tfail_str = ''\\n\\t\\tfiles = []\\n\\t\\tfor config_file in configs:\\n\\t\\t\\tif isinstance(config_file, tuple):\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tif not shutit_util.is_file_secure(config_file):\\n\\t\\t\\t\\tfail_str = fail_str + '\\\\nchmod 0600 ' + config_file\\n\\t\\t\\t\\tfiles.append(config_file)\\n\\t\\tif fail_str != '':\\n\\t\\t\\tif shutit_global.shutit_global_object.interactive > 1:\\n\\t\\t\\t\\tfail_str = 'Files are not secure, mode should be 0600. Running the following commands to correct:\\\\n' + fail_str + '\\\\n'\\n\\t\\t\\t\\t# Actually show this to the user before failing...\\n\\t\\t\\t\\tself.log(fail_str,level=logging.INFO)\\n\\t\\t\\t\\tself.log('Do you want me to run this for you? (input y/n)',level=logging.INFO)\\n\\t\\t\\t\\tif shutit_global.shutit_global_object.interactive == 0 or shutit_util.util_raw_input(default='y') == 'y':\\n\\t\\t\\t\\t\\tfor f in files:\\n\\t\\t\\t\\t\\t\\tself.log('Correcting insecure file permissions on: ' + f,level=logging.INFO)\\n\\t\\t\\t\\t\\t\\tos.chmod(f,0o600)\\n\\t\\t\\t\\t\\t# recurse\\n\\t\\t\\t\\t\\treturn self.get_configs(configs)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfor f in files:\\n\\t\\t\\t\\t\\tself.log('Correcting insecure file permissions on: ' + f,level=logging.INFO)\\n\\t\\t\\t\\t\\tos.chmod(f,0o600)\\n\\t\\t\\t\\t# recurse\\n\\t\\t\\t\\treturn self.get_configs(configs)\\n\\t\\t\\tself.fail(fail_str) # pragma: no cover\\n\\t\\tfor config in configs:\\n\\t\\t\\tif isinstance(config, tuple):\\n\\t\\t\\t\\tcp.readfp(config[1], filename=config[0])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tcp.read(config)\\n\\t\\t# Treat allowed_images as a special, additive case\\n\\t\\tself.build['shutit.core.module.allowed_images'] = cp.get_config_set('build', 'shutit.core.module.allowed_images')\\n\\t\\treturn cp\",\n \"def load_configs(self):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\t# Get root default config.\\n\\t\\t# TODO: change default_cnf so it places whatever the values are at this stage of the build.\\n\\t\\tconfigs = [('defaults', StringIO(default_cnf)), os.path.expanduser('~/.shutit/config'), os.path.join(self.host['shutit_path'], 'config'), 'configs/build.cnf']\\n\\t\\t# Add the shutit global host- and user-specific config file.\\n\\t\\t# Add the local build.cnf\\n\\t\\t# Get passed-in config(s)\\n\\t\\tfor config_file_name in self.build['extra_configs']:\\n\\t\\t\\trun_config_file = os.path.expanduser(config_file_name)\\n\\t\\t\\tif not os.path.isfile(run_config_file):\\n\\t\\t\\t\\tshutit_global.shutit_global_object.shutit_print('Did not recognise ' + run_config_file + ' as a file - do you need to touch ' + run_config_file + '?')\\n\\t\\t\\t\\tshutit_global.shutit_global_object.handle_exit(exit_code=0)\\n\\t\\t\\tconfigs.append(run_config_file)\\n\\t\\t# Image to use to start off. The script should be idempotent, so running it\\n\\t\\t# on an already built image should be ok, and is advised to reduce diff space required.\\n\\t\\tif self.action['list_configs'] or self.loglevel <= logging.DEBUG:\\n\\t\\t\\tmsg = ''\\n\\t\\t\\tfor c in configs:\\n\\t\\t\\t\\tif isinstance(c, tuple):\\n\\t\\t\\t\\t\\tc = c[0]\\n\\t\\t\\t\\tmsg = msg + ' \\\\n' + c\\n\\t\\t\\t\\tself.log(' ' + c,level=logging.DEBUG)\\n\\n\\t\\t# Interpret any config overrides, write to a file and add them to the\\n\\t\\t# list of configs to be interpreted\\n\\t\\tif self.build['config_overrides']:\\n\\t\\t\\t# We don't need layers, this is a temporary configparser\\n\\t\\t\\toverride_cp = ConfigParser.RawConfigParser()\\n\\t\\t\\tfor o_sec, o_key, o_val in self.build['config_overrides']:\\n\\t\\t\\t\\tif not override_cp.has_section(o_sec):\\n\\t\\t\\t\\t\\toverride_cp.add_section(o_sec)\\n\\t\\t\\t\\toverride_cp.set(o_sec, o_key, o_val)\\n\\t\\t\\toverride_fd = StringIO()\\n\\t\\t\\toverride_cp.write(override_fd)\\n\\t\\t\\toverride_fd.seek(0)\\n\\t\\t\\tconfigs.append(('overrides', override_fd))\\n\\n\\t\\tself.config_parser = self.get_configs(configs)\\n\\t\\tself.get_base_config()\",\n \"def load_custom_filters(environment):\\n\\n # TODO deprecate ipaddr_index and netmask for the better ipnet ones\\n filter_list = {\\n 'dpkg_arch': filter_dpkg_arch,\\n 'storage_size_num': filter_storage_size_num,\\n 'ipnet_hostaddr': filter_ipnet_hostaddr,\\n 'ipnet_hostmin': filter_ipnet_hostmin,\\n 'ipnet_hostmax': filter_ipnet_hostmax,\\n 'ipnet_broadcast': filter_ipnet_broadcast,\\n 'ipnet_netmask': filter_ipnet_netmask,\\n 'ipnet_contains_ip': filter_ipnet_contains_ip,\\n 'ipnet_contains_iprange': filter_ipnet_contains_iprange,\\n 'ipnet_range_size': filter_ipnet_range_size,\\n 'ipaddr_index': filter_ipaddr_index,\\n 'netmask': filter_netmask\\n }\\n\\n for name, function in filter_list.items():\\n environment.filters[name] = function\",\n \"def _load_common_config(self, config: Dict[str, Any]) -> Dict[str, Any] :\\n # Log level\\n if 'loglevel' in self.args.loglevel:\\n config.update({'verbosity': self.args.loglevel})\\n else:\\n config.update({'verbosity': 0})\\n logging.basicConfig(\\n level=logging.INFO if config['verbosity'] < 1 else logging.DEBUG,\\n format= '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\\n )\\n set_loggers(config['verbosity'])\\n logger.info('Verbosity set to %s', config['verbosity'])\\n\\n # Add dynamic whitelist if found\\n if 'dynamic_whitelist' in self.args and self.args.dynamic_whitelist:\\n config['pairlist'] = {\\n 'method': 'VolumePairList',\\n 'config': {'number_assets': self.args.dynamic_whitelist}\\n }\\n logger.warning(\\n 'Parameter --dynamic-whitelist has been deprecated, '\\n 'and will be completely replaced by the whitelist dict in the future. '\\n 'For now: using dynamically generated whitelist based on VolumePairList. '\\n '(not applicable with Backtesting and Hyperopt)'\\n )\\n if self.args.db_url and self.args.db_url != constant.DEFAULT_DB_PROD_URL:\\n config.update({'db_url': self.args.db_url})\\n logger.info('Parameter --db-url detected ...')\\n\\n if config.get('dry_run', False):\\n logger.info('Dry run is enabled')\\n if config.get('db_url') in [None, constant.DEFAULT_DB_PROD_URL]:\\n # Default to in-memory db for dry_run if not specified\\n config['db_url'] = constant.DEFAULT_DB_DRYRUN_URL\\n else:\\n if not config.get('db_url', None):\\n config['db_url'] = constant.DEFAULT_DB_PROD_URL\\n logger.info('Dry run is disabled')\\n\\n if config.get('forcebuy_enable', False):\\n logger.warning('`forcebuy` RPC message enabled.')\\n\\n # Setting max_open_trades to infinite if -1\\n if config.get('max_open_trades') == -1:\\n config['max_open_trades'] = float('inf')\\n\\n logger.info(f'Using DB: \\\"{config[\\\"db_url\\\"]}\\\"')\\n\\n # Check if the exchange set by the user is supported\\n self.check_exchange(config)\\n\\n return config\",\n \"def preprocess(self, cfg_pipeline):\\n return\",\n \"def make_modules(self, config):\\n pass\",\n \"def main():\\n logger = logging.getLogger(__name__)\\n logger.info('making final data set from raw data')\\n get_user_config()\",\n \"def loadConfigs(self):\\n self.onLoadConfig(urlopen(self.inipath))\",\n \"def initialize_from_config(self):\",\n \"def use_config_file(self):\\n self.config_file = self.find_config_file()\\n if self.config_file:\\n self.apply_config_file(self.config_file)\",\n \"def get_filter_config(\\n platform,\\n filter_name,\\n filter_options=None,\\n terms=None,\\n prepend=True,\\n pillar_key=\\\"acl\\\",\\n pillarenv=None,\\n saltenv=None,\\n merge_pillar=True,\\n only_lower_merge=False,\\n revision_id=None,\\n revision_no=None,\\n revision_date=True,\\n revision_date_format=\\\"%Y/%m/%d\\\",\\n):\\n if not filter_options:\\n filter_options = []\\n if not terms:\\n terms = []\\n if merge_pillar and not only_lower_merge:\\n acl_pillar_cfg = _get_pillar_cfg(\\n pillar_key, saltenv=saltenv, pillarenv=pillarenv\\n )\\n filter_pillar_cfg = _lookup_element(acl_pillar_cfg, filter_name)\\n filter_options = filter_options or filter_pillar_cfg.pop(\\\"options\\\", None)\\n if filter_pillar_cfg:\\n # Only when it was able to find the filter in the ACL config\\n pillar_terms = filter_pillar_cfg.get(\\n \\\"terms\\\", []\\n ) # No problem if empty in the pillar\\n terms = _merge_list_of_dict(terms, pillar_terms, prepend=prepend)\\n # merge the passed variable with the pillar data\\n # any filter term not defined here, will be appended from the pillar\\n # new terms won't be removed\\n filters = []\\n filters.append(\\n {\\n filter_name: {\\n \\\"options\\\": _make_it_list({}, filter_name, filter_options),\\n \\\"terms\\\": terms,\\n }\\n }\\n )\\n return get_policy_config(\\n platform,\\n filters=filters,\\n pillar_key=pillar_key,\\n pillarenv=pillarenv,\\n saltenv=saltenv,\\n merge_pillar=merge_pillar,\\n only_lower_merge=True,\\n revision_id=revision_id,\\n revision_no=revision_no,\\n revision_date=revision_date,\\n revision_date_format=revision_date_format,\\n )\",\n \"def create_file_list(source_root_dir, filtering_output_file, filtering_options_file, initial_filtering_list=''):\\n\\n # Print a status message\\n logging.info('')\\n logging.info('\\\\tCreating analysis filtering list...')\\n logging.info('\\\\t>> Executing command: create_file_list.create_file_list(%s, %s, %s, %s)', source_root_dir,\\n filtering_output_file, filtering_options_file, initial_filtering_list)\\n logging.info('\\\\t>> From directory: %s', os.getcwd())\\n\\n # Initialize the variables\\n # filtering_options = []\\n raw_file_list = []\\n default_filtering_options_file = os.path.abspath(os.path.dirname(os.path.abspath(__file__)) + '/FilteringDefaults')\\n\\n # Create the list of all available files, if necessary\\n if os.path.isfile(initial_filtering_list):\\n # Read in the list\\n with open(initial_filtering_list, 'r') as input_fh:\\n raw_file_list = [line.strip() for line in input_fh.readlines()]\\n else:\\n for root, dir_names, file_names, in os.walk(source_root_dir):\\n for file_name in file_names:\\n raw_file_list.append(os.path.join(root, file_name))\\n\\n # # Read in the default filtering options\\n # filtering_options = filtering_options + parse_filtering_file(default_filtering_options_file)\\n\\n # Read in the values from the filtering file and add them to the list\\n if os.path.isfile(filtering_options_file):\\n # Print a status message\\n logging.info('')\\n logging.info('\\\\tParsing input file.')\\n\\n # Parse the filtering file\\n filtering_options = (parse_filtering_file(filtering_options_file) +\\n parse_filtering_file(default_filtering_options_file))\\n\\n else:\\n # Print a warning message\\n logging.info('')\\n logging.info('\\\\tNo filtering file was found or no filtering file was provided. Using default values.')\\n\\n # Parse the filtering file\\n filtering_options = parse_filtering_file(default_filtering_options_file)\\n\\n # Modify the list based on the include and exclude options\\n filtered_file_list = raw_file_list.copy()\\n for filtering_option in filtering_options:\\n for file_path in raw_file_list:\\n if re.search(filtering_option[1], file_path) and filtering_option[0] == '-' and file_path in filtered_file_list:\\n filtered_file_list.remove(file_path)\\n\\n elif re.search(filtering_option[1], file_path) and filtering_option[0] == '+' and file_path not in filtered_file_list:\\n filtered_file_list.append(file_path)\\n\\n # Print the results to the output file\\n with open(filtering_output_file, 'w') as output_fh:\\n for filtered_file in filtered_file_list:\\n if filtered_file.startswith('/'):\\n relative_path = os.path.relpath(filtered_file, source_root_dir)\\n else:\\n relative_path = filtered_file\\n output_fh.write('%s\\\\n' % relative_path)\",\n \"def add_catalogs(self):\\n n_exposures = len(self.info['Module'])\\n self.info['point_source'] = [None] * n_exposures\\n self.info['galaxyListFile'] = [None] * n_exposures\\n self.info['extended'] = [None] * n_exposures\\n self.info['convolveExtended'] = [False] * n_exposures\\n self.info['movingTarg'] = [None] * n_exposures\\n self.info['movingTargSersic'] = [None] * n_exposures\\n self.info['movingTargExtended'] = [None] * n_exposures\\n self.info['movingTargToTrack'] = [None] * n_exposures\\n\\n for i in range(n_exposures):\\n if int(self.info['detector'][i][-1]) < 5:\\n filtkey = 'ShortFilter'\\n pupilkey = 'ShortPupil'\\n else:\\n filtkey = 'LongFilter'\\n pupilkey = 'LongPupil'\\n filt = self.info[filtkey][i]\\n pup = self.info[pupilkey][i]\\n\\n if self.point_source[i] is not None:\\n # In here, we assume the user provided a catalog to go with each filter\\n # so now we need to find the filter for each entry and generate a list that makes sense\\n self.info['point_source'][i] = os.path.abspath(os.path.expandvars(\\n self.catalog_match(filt, pup, self.point_source, 'point source')))\\n else:\\n self.info['point_source'][i] = None\\n if self.galaxyListFile[i] is not None:\\n self.info['galaxyListFile'][i] = os.path.abspath(os.path.expandvars(\\n self.catalog_match(filt, pup, self.galaxyListFile, 'galaxy')))\\n else:\\n self.info['galaxyListFile'][i] = None\\n if self.extended[i] is not None:\\n self.info['extended'][i] = os.path.abspath(os.path.expandvars(\\n self.catalog_match(filt, pup, self.extended, 'extended')))\\n else:\\n self.info['extended'][i] = None\\n if self.movingTarg[i] is not None:\\n self.info['movingTarg'][i] = os.path.abspath(os.path.expandvars(\\n self.catalog_match(filt, pup, self.movingTarg, 'moving point source target')))\\n else:\\n self.info['movingTarg'][i] = None\\n if self.movingTargSersic[i] is not None:\\n self.info['movingTargSersic'][i] = os.path.abspath(os.path.expandvars(\\n self.catalog_match(filt, pup, self.movingTargSersic, 'moving sersic target')))\\n else:\\n self.info['movingTargSersic'][i] = None\\n if self.movingTargExtended[i] is not None:\\n self.info['movingTargExtended'][i] = os.path.abspath(os.path.expandvars(\\n self.catalog_match(filt, pup, self.movingTargExtended, 'moving extended target')))\\n else:\\n self.info['movingTargExtended'][i] = None\\n if self.movingTargToTrack[i] is not None:\\n self.info['movingTargToTrack'][i] = os.path.abspath(os.path.expandvars(\\n self.catalog_match(filt, pup, self.movingTargToTrack, 'non-sidereal moving target')))\\n else:\\n self.info['movingTargToTrack'][i] = None\\n if self.convolveExtended is True:\\n self.info['convolveExtended'] = [True] * n_exposures\",\n \"def preload_all_configs(self):\\n for _, _, filenames in os.walk(self.configDir):\\n for filename in filenames:\\n if filename[-3:] == \\\".py\\\" and filename != \\\"__init__.py\\\":\\n configID = filename[0:-3]\\n self.load_config(configID)\",\n \"def __init__(self, config_file):\\n # Parse configuration file\\n self.config_file = config_file\\n self.config = ConfigParser.SafeConfigParser()\\n self.config.read(self.config_file)\\n\\n self.source_do_purge = self.config.getboolean(\\\"source\\\", \\\"do_purge\\\")\\n self.source_requests_dir = self.config.get(\\\"source\\\", \\\"requests_dir\\\")\\n\\n self.add_console_handler = self.config.getboolean(\\\"source\\\", \\\"add_console_handler\\\")\\n self.add_file_handler = self.config.getboolean(\\\"source\\\", \\\"add_file_handler\\\")\\n self.log_file_name = self.config.get(\\\"source\\\", \\\"log_file_name\\\")\\n log_level = self.config.get(\\\"source\\\", \\\"log_level\\\")\\n if log_level == 'DEBUG':\\n self.log_level = logging.DEBUG\\n elif log_level == 'INFO':\\n self.log_level = logging.INFO\\n elif log_level == 'WARNING':\\n self.log_level = logging.WARNING\\n elif log_level == 'ERROR':\\n self.log_level = logging.ERROR\\n elif log_level == 'CRITICAL':\\n self.log_level = logging.CRITICAL\\n\\n self.author_config_file = self.config.get(\\\"author\\\", \\\"config_file\\\")\\n self.author_do_purge = self.config.getboolean(\\\"author\\\", \\\"do_purge\\\")\\n self.author_requests_dir = self.config.get(\\\"author\\\", \\\"requests_dir\\\")\\n\\n self.flickr_content_dir = self.config.get(\\\"flickr\\\", \\\"content_dir\\\")\\n self.tumblr_content_dir = self.config.get(\\\"tumblr\\\", \\\"content_dir\\\")\\n self.twitter_content_dir = self.config.get(\\\"twitter\\\", \\\"content_dir\\\")\\n\\n self.tumblr_min_total_tags = self.config.getint(\\\"tumblr\\\", \\\"min_total_tags\\\")\\n self.tumblr_min_total_blogs = self.config.getint(\\\"tumblr\\\", \\\"min_total_blogs\\\")\\n\\n # Create a logger\\n root = logging.getLogger()\\n root.setLevel(self.log_level)\\n formatter = logging.Formatter(\\n \\\"%(asctime)s %(name)s %(levelname)s: %(message)s\\\", \\\"%Y-%m-%d %H:%M:%S\\\")\\n for handler in root.handlers:\\n root.removeHandler(handler)\\n if self.add_console_handler:\\n console_handler = logging.StreamHandler()\\n console_handler.setFormatter(formatter)\\n root.addHandler(console_handler)\\n if self.add_file_handler:\\n file_handler = logging.handlers.RotatingFileHandler(\\n self.log_file_name, maxBytes=1000000, backupCount=5, encoding='utf-8')\\n file_handler.setFormatter(formatter)\\n root.addHandler(file_handler)\\n\\n self.logger = logging.getLogger(u\\\"BluPenSource\\\")\",\n \"def parse(self):\\n\\t\\tself.maincfg_values = self._load_static_file(self.cfg_file)\\n\\t\\t\\n\\t\\tself.cfg_files = self.get_cfg_files()\\n\\t\\t\\n\\t\\tself.resource_values = self.get_resources()\\n\\t\\t\\n\\t\\tself.timestamps = self.get_timestamps()\\n\\t\\t\\n\\t\\t## This loads everything into\\n\\t\\tfor cfg_file in self.cfg_files:\\n\\t\\t\\tself._load_file(cfg_file)\\n\\n\\t\\tself._post_parse()\",\n \"def __init__(self, config, *parse_list):\\n super(ParsingFilter, self).__init__()\\n self.config = config\\n try:\\n if (\\n self.config[\\\"filter\\\"][\\\"whitelist\\\"]\\n and self.config[\\\"filter\\\"][\\\"blacklist\\\"]\\n ):\\n _LOGGER.warning(\\n _(\\n \\\"Both whitelist and blacklist filters found in configuration. \\\"\\n \\\"Only one can be used at a time - only the whitelist filter will be used.\\\"\\n )\\n )\\n self.parse_list = [\\n logging.Filter(name) for name in parse_list[0][\\\"whitelist\\\"]\\n ]\\n except KeyError:\\n self.parse_list = parse_list[0].get(\\\"whitelist\\\") or parse_list[0].get(\\n \\\"blacklist\\\"\\n )\\n\\n self.parse_list = [logging.Filter(name) for name in self.parse_list]\",\n \"def init_config(self):\\n super().init_config()\\n for param in self.parameters():\\n if param.name == 'source':\\n continue\\n self.add_config_item(param.name,\\n saver=lambda p=param: getattr(p, \\\"value\\\"),\\n loader=lambda x, p=param: setattr(p, \\\"value\\\", x),\\n default=param.default)\",\n \"def config_collection(self):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\tself.log('In config_collection',level=logging.DEBUG)\\n\\t\\tcfg = self.cfg\\n\\t\\tfor module_id in self.module_ids():\\n\\t\\t\\t# Default to None so we can interpret as ifneeded\\n\\t\\t\\tself.get_config(module_id, 'shutit.core.module.build', None, boolean=True, forcenone=True)\\n\\t\\t\\tself.get_config(module_id, 'shutit.core.module.remove', False, boolean=True)\\n\\t\\t\\tself.get_config(module_id, 'shutit.core.module.tag', False, boolean=True)\\n\\t\\t\\t# Default to allow any image\\n\\t\\t\\tself.get_config(module_id, 'shutit.core.module.allowed_images', [\\\".*\\\"])\\n\\t\\t\\tmodule = self.shutit_map[module_id]\\n\\t\\t\\tcfg_file = os.path.dirname(get_module_file(self,module)) + '/configs/build.cnf'\\n\\t\\t\\tif os.path.isfile(cfg_file):\\n\\t\\t\\t\\t# use self.get_config, forcing the passed-in default\\n\\t\\t\\t\\tconfig_parser = ConfigParser.ConfigParser()\\n\\t\\t\\t\\tconfig_parser.read(cfg_file)\\n\\t\\t\\t\\tfor section in config_parser.sections():\\n\\t\\t\\t\\t\\tif section == module_id:\\n\\t\\t\\t\\t\\t\\tfor option in config_parser.options(section):\\n\\t\\t\\t\\t\\t\\t\\tif option == 'shutit.core.module.allowed_images':\\n\\t\\t\\t\\t\\t\\t\\t\\toverride = False\\n\\t\\t\\t\\t\\t\\t\\t\\tfor mod, opt, val in self.build['config_overrides']:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tval = val # pylint\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# skip overrides\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif mod == module_id and opt == option:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\toverride = True\\n\\t\\t\\t\\t\\t\\t\\t\\tif override:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\t\\t\\tvalue = config_parser.get(section,option)\\n\\t\\t\\t\\t\\t\\t\\t\\tif option == 'shutit.core.module.allowed_images':\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tvalue = json.loads(value)\\n\\t\\t\\t\\t\\t\\t\\t\\tself.get_config(module_id, option, value, forceask=True)\\n\\t\\t\\t# ifneeded will (by default) only take effect if 'build' is not\\n\\t\\t\\t# specified. It can, however, be forced to a value, but this\\n\\t\\t\\t# should be unusual.\\n\\t\\t\\tif cfg[module_id]['shutit.core.module.build'] is None:\\n\\t\\t\\t\\tself.get_config(module_id, 'shutit.core.module.build_ifneeded', True, boolean=True)\\n\\t\\t\\t\\tcfg[module_id]['shutit.core.module.build'] = False\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.get_config(module_id, 'shutit.core.module.build_ifneeded', False, boolean=True)\",\n \"def _add_fp_configs(CONFIG):\\n CONFIG.declare(\\n 'fp_cutoffdecr',\\n ConfigValue(\\n default=1e-1,\\n domain=PositiveFloat,\\n description='Additional relative decrement of cutoff value for the original objective function.',\\n ),\\n )\\n CONFIG.declare(\\n 'fp_iteration_limit',\\n ConfigValue(\\n default=20,\\n domain=PositiveInt,\\n description='Feasibility pump iteration limit',\\n doc='Number of maximum iterations in the feasibility pump methods.',\\n ),\\n )\\n # TODO: integrate this option\\n CONFIG.declare(\\n 'fp_projcuts',\\n ConfigValue(\\n default=True,\\n description='Whether to add cut derived from regularization of MIP solution onto NLP feasible set.',\\n domain=bool,\\n ),\\n )\\n CONFIG.declare(\\n 'fp_transfercuts',\\n ConfigValue(\\n default=True,\\n description='Whether to transfer cuts from the Feasibility Pump MIP to main MIP in selected strategy (all except from the round in which the FP MIP became infeasible).',\\n domain=bool,\\n ),\\n )\\n CONFIG.declare(\\n 'fp_projzerotol',\\n ConfigValue(\\n default=1e-4,\\n domain=PositiveFloat,\\n description='Tolerance on when to consider optimal value of regularization problem as zero, which may trigger the solution of a Sub-NLP.',\\n ),\\n )\\n CONFIG.declare(\\n 'fp_mipgap',\\n ConfigValue(\\n default=1e-2,\\n domain=PositiveFloat,\\n description='Optimality tolerance (relative gap) to use for solving MIP regularization problem.',\\n ),\\n )\\n CONFIG.declare(\\n 'fp_discrete_only',\\n ConfigValue(\\n default=True,\\n description='Only calculate the distance among discrete variables in regularization problems.',\\n domain=bool,\\n ),\\n )\\n CONFIG.declare(\\n 'fp_main_norm',\\n ConfigValue(\\n default='L1',\\n domain=In(['L1', 'L2', 'L_infinity']),\\n description='Different forms of objective function MIP regularization problem.',\\n ),\\n )\\n CONFIG.declare(\\n 'fp_norm_constraint',\\n ConfigValue(\\n default=True,\\n description='Whether to add the norm constraint to FP-NLP',\\n domain=bool,\\n ),\\n )\\n CONFIG.declare(\\n 'fp_norm_constraint_coef',\\n ConfigValue(\\n default=1,\\n domain=PositiveFloat,\\n description='The coefficient in the norm constraint, correspond to the Beta in the paper.',\\n ),\\n )\",\n \"def set_conf_files(application):\\n example_dir = \\\"./docs/examples/configs/example_4\\\"\\n application.config['GROUPS_FILE'] = example_dir + \\\"/groups.yml\\\"\\n application.config['POLICIES_FILE'] = example_dir + \\\"/policies.yml\\\"\",\n \"def load_config(self):\\n if self.get_vrps():\\n self.process_vrps()\",\n \"def applyFiltersForIntermediate(ID, SEQUENCES, FINALCLASSIFICATION, CONFIG, DICOLIBRARIES):\\n\\t#### First we check if tools used to detect the TE are from the removedTool or the onlySelectedtools of the CONFIG file\\n\\t#### Parse the dictionnary containing CONFIG information\\n\\tfor sortedOutput in CONFIG:\\n\\t\\t#### Look for te finalClassification corresponding to the sequence\\n\\t\\tif CONFIG[sortedOutput][\\\"finalClassification\\\"].lower() == FINALCLASSIFICATION.lower():\\n\\t\\t\\t#### Find if the tool used to find the TE is a part of the removedTool from the CONFIG file : True it is find, else False\\n\\t\\t\\tfindRemovedTool=False\\n\\t\\t\\tfor removedTool in CONFIG[sortedOutput][\\\"removedTools\\\"]:\\n\\t\\t\\t\\tif ID.lower().find(removedTool.lower()) == 0:\\n\\t\\t\\t\\t\\tfindRemovedTool=True\\n\\n\\t\\t\\t#### Find if the tool used to find the TE is one of the onlySelectedtools from the CONFIG file : True it is find, else False\\n\\t\\t\\tfindSelectedTool=False\\n\\t\\t\\tfor selectedTool in CONFIG[sortedOutput][\\\"onlySelectedtools\\\"]:\\n\\t\\t\\t\\tif ID.lower().find(selectedTool.lower()) == 0 or selectedTool.lower() == \\\"na\\\":\\n\\t\\t\\t\\t\\tfindSelectedTool=True\\n\\n\\t\\t\\t#### Control the length of the sequence with the CONFIG\\n\\t\\t\\tif SEQUENCES[ID][\\\"length\\\"] >= CONFIG[sortedOutput][\\\"lengthMin\\\"] and SEQUENCES[ID][\\\"length\\\"] < CONFIG[sortedOutput][\\\"lengthMax\\\"]:\\n\\t\\t\\t\\t#### Control if the tool used to detect TE is in the removedTool : if not, sequence can be in library autonomous TE\\n\\t\\t\\t\\tif not findRemovedTool and findSelectedTool:\\n\\t\\t\\t\\t\\t\\t#### Save intermediate libraries\\n\\t\\t\\t\\t\\t\\tsave.saveIntermadiateLibraries(SEQUENCES, ID, CONFIG, sortedOutput)\",\n \"def configure(self):\\n self.data_batch_file = self.get_value_from_config('data_batch_file')\\n self.batch_meta_file = self.get_value_from_config('batch_meta_file')\\n self.has_background = self.get_value_from_config('has_background')\\n self.num_classes = self.get_value_from_config('num_classes')\\n self.converted_images_dir = self.get_value_from_config('converted_images_dir')\\n if not self.converted_images_dir:\\n self.converted_images_dir = self.data_batch_file.parent / 'converted_images'\\n self.convert_images = self.get_value_from_config('convert_images')\\n # create directory for storing images if it is necessary\\n if self.convert_images and not self.converted_images_dir.exists():\\n self.converted_images_dir.mkdir(parents=True)\\n self.dataset_meta = self.get_value_from_config('dataset_meta_file')\",\n \"def createIntermediateLibraries(LISTPRELIBRARIES, DICOLIBRARIES, CONFIG, DICOFINALCLASSIF):\\n\\t#### Parse all the intermediate libraries files\\n\\tfor preLibrary in LISTPRELIBRARIES:\\n\\t\\t#### Retrieve the final classification name of the ET from the file name\\n\\t\\tfinalClassification = os.path.basename(preLibrary).split(\\\".fasta\\\")[0]\\n\\t\\t#### Read and store the fasta sequences of the prelibraries\\n\\t\\tsequences=readInput.readFasta(preLibrary)\\n\\t\\t#### Parse all the sequences\\n\\t\\tfor id in sequences:\\n\\t\\t\\t#### Check the finalClassification of the sequences is in the ID\\n\\t\\t\\tif finalClassification.lower() in id.lower():\\n\\t\\t\\t\\tDICOFINALCLASSIF[id]=finalClassification\\n\\t\\t\\t\\tapplyFiltersForIntermediate(id, sequences, finalClassification, CONFIG, DICOLIBRARIES)\",\n \"def configure_filters(app):\\n\\n for (name, filter) in _filters.iteritems():\\n app.jinja_env.filters[name] = filter\",\n \"def init_configs(self):\\n\\n # get current location\\n self.script_dir = os.path.dirname(__file__)\\n\\n # load configuration file\\n with open(os.path.join(self.script_dir, \\\"config.json\\\")) as f:\\n self.configs = json.load(f)\\n \\n # load some configs as attributes\\n self.resource_folder = os.path.join(self.script_dir, self.configs[\\\"resource_path\\\"], self.resource_type, self.language)\\n self.pre_processed_folder = os.path.join(self.resource_folder, self.configs[\\\"pre_processed_path\\\"])\\n self.results_folder = os.path.join(self.resource_folder, self.configs[\\\"results_path\\\"])\\n self.chunk_size = self.configs[\\\"resources\\\"][self.resource_type][\\\"chunk_size\\\"]\",\n \"def reffile_setup(self):\\n # Prepare to find files listed as 'config'\\n # and set up PSF path\\n\\n # set up as dictionary of dictionaries\\n self.configfiles = {}\\n self.psfpath = {}\\n self.psfbasename = {}\\n self.psfpixfrac = {}\\n self.reference_file_dir = {}\\n\\n for instrument in 'nircam niriss fgs'.split():\\n self.configfiles[instrument] = {}\\n self.psfpath[instrument] = os.path.join(self.datadir, instrument, 'gridded_psf_library')\\n self.psfbasename[instrument] = instrument\\n self.reference_file_dir[instrument] = os.path.join(self.datadir, instrument, 'reference_files')\\n\\n # Set instrument-specific file paths\\n if instrument == 'nircam':\\n self.psfpixfrac[instrument] = 0.25\\n elif instrument == 'niriss':\\n self.psfpixfrac[instrument] = 0.1\\n elif instrument == 'fgs':\\n self.psfpixfrac[instrument] = 0.1\\n\\n # Set global file paths\\n self.configfiles[instrument]['filter_throughput'] = os.path.join(self.modpath, 'config', 'placeholder.txt')\\n\\n for instrument in 'miri nirspec'.split():\\n self.configfiles[instrument] = {}\\n self.psfpixfrac[instrument] = 0\\n self.psfbasename[instrument] = 'N/A'\\n\\n # create empty dictionaries\\n list_names = 'superbias linearity gain saturation ipc astrometric photom pam dark lindark'.split()\\n for list_name in list_names:\\n setattr(self, '{}_list'.format(list_name), {})\\n\\n self.det_list = {}\\n self.det_list['nircam'] = ['A1', 'A2', 'A3', 'A4', 'A5', 'B1', 'B2', 'B3', 'B4', 'B5']\\n self.det_list['niriss'] = ['NIS']\\n self.det_list['fgs'] = ['G1', 'G2']\\n self.det_list['nirspec'] = ['NRS']\\n self.det_list['miri'] = ['MIR']\\n\\n for instrument in 'nircam niriss fgs miri nirspec'.split():\\n for list_name in list_names:\\n getattr(self, '{}_list'.format(list_name))[instrument] = {}\\n\\n if self.offline:\\n # no access to central store. Set all files to none.\\n for list_name in list_names:\\n if list_name in 'dark lindark'.split():\\n default_value = ['None']\\n else:\\n default_value = 'None'\\n for det in self.det_list[instrument]:\\n getattr(self, '{}_list'.format(list_name))[instrument][det] = default_value\\n\\n elif instrument == 'nircam':\\n rawdark_dir = os.path.join(self.datadir, 'nircam/darks/raw')\\n lindark_dir = os.path.join(self.datadir, 'nircam/darks/linearized')\\n for det in self.det_list[instrument]:\\n self.dark_list[instrument][det] = glob(os.path.join(rawdark_dir, det, '*.fits'))\\n self.lindark_list[instrument][det] = glob(os.path.join(lindark_dir, det, '*.fits'))\\n\\n elif instrument in ['nirspec', 'miri']:\\n for key in 'subarray_def_file fluxcal filtpupil_pairs readpatt_def_file crosstalk ' \\\\\\n 'dq_init_config saturation_config superbias_config refpix_config ' \\\\\\n 'linearity_config filter_throughput'.split():\\n self.configfiles[instrument][key] = 'N/A'\\n default_value = 'none'\\n for list_name in list_names:\\n for det in self.det_list[instrument]:\\n getattr(self, '{}_list'.format(list_name))[instrument][det] = default_value\\n\\n else: # niriss and fgs\\n for det in self.det_list[instrument]:\\n if det == 'G1':\\n self.dark_list[instrument][det] = glob(os.path.join(self.datadir, 'fgs/darks/raw', FGS1_DARK_SEARCH_STRING))\\n self.lindark_list[instrument][det] = glob(os.path.join(self.datadir, 'fgs/darks/linearized', FGS1_DARK_SEARCH_STRING))\\n\\n elif det == 'G2':\\n self.dark_list[instrument][det] = glob(os.path.join(self.datadir, 'fgs/darks/raw', FGS2_DARK_SEARCH_STRING))\\n self.lindark_list[instrument][det] = glob(os.path.join(self.datadir, 'fgs/darks/linearized', FGS2_DARK_SEARCH_STRING))\\n\\n elif det == 'NIS':\\n self.dark_list[instrument][det] = glob(os.path.join(self.datadir, 'niriss/darks/raw',\\n '*uncal.fits'))\\n self.lindark_list[instrument][det] = glob(os.path.join(self.datadir, 'niriss/darks/linearized',\\n '*linear_dark_prep_object.fits'))\",\n \"def config():\",\n \"def config():\",\n \"def lambda2(case_config_filepath, render_config_filepath):\\n\\n # Load config file with all common directory names\\n dirname_config = configparser.ConfigParser()\\n dirname_config.read(\\\"dirname.cfg\\\")\\n\\n # Get information from config files\\n cconfd = load_config.get_config_params(case_config_filepath)\\n rconfd = load_config.get_config_params(render_config_filepath)\\n \\n # Main output directory\\n case_output = dirname_config[\\\"DIRECTORIES\\\"][\\\"RenderOutput\\\"] + cconfd[\\\"case_name\\\"] + \\\"/\\\"\\n\\n # Determine lambda2 output directories and make them if necessary\\n lambda2_level = rconfd[\\\"lambda2_level\\\"]\\n lambda2_specifier = \\\"l2\\\" + str(lambda2_level) + \\\"/\\\"\\n geometry_output_dir = case_output + dirname_config[\\\"DIRECTORIES\\\"][\\\"ply\\\"]\\n ply_lambda2_output_dir = case_output + dirname_config[\\\"DIRECTORIES\\\"][\\\"ply_lambda2\\\"] + lambda2_specifier\\n image_lambda2_output_dir = case_output + dirname_config[\\\"DIRECTORIES\\\"][\\\"tstep_lambda2\\\"] + lambda2_specifier\\n image_lambda2_output_dir_spec = dircheck.count_png_dirs(image_lambda2_output_dir)\\n dircheck.check_make([ply_lambda2_output_dir, image_lambda2_output_dir_spec])\\n\\n # Write Blender config file\\n blender_config_filedir = case_output + rconfd[\\\"render_name\\\"] + \\\"_blender.cfg\\\"\\n load_config.write_config_file(config_filedir=blender_config_filedir,\\n config_dict={\\\"image_output_dir_spec\\\": image_lambda2_output_dir_spec,\\n \\\"ply_input_dir\\\": ply_lambda2_output_dir,\\n \\\"interface_material_name\\\": \\\"Lambda2Contour\\\",\\n \\\"bg_image_filepath\\\": rconfd[\\\"bg_image_filepath\\\"],\\n \\\"view_fraction\\\": rconfd[\\\"view_fraction\\\"], \\\"render_scale\\\": 10,\\n \\\"resolution_percentage\\\": rconfd[\\\"resolution_percentage\\\"],\\n \\\"xres\\\": cconfd[\\\"xres\\\"], \\\"yres\\\": cconfd[\\\"yres\\\"], \\\"zres\\\": cconfd[\\\"zres\\\"],\\n \\\"tres\\\": cconfd[\\\"tres\\\"], \\\"interface_half_enabled\\\": False,\\n \\\"fog_enabled\\\": False,\\n \\\"camera_azimuth_angle\\\": rconfd[\\\"camera_azimuth_angle\\\"],\\n \\\"camera_elevation_angle\\\": rconfd[\\\"camera_elevation_angle\\\"],\\n \\\"bg_color_1\\\": rconfd[\\\"bg_color_1\\\"], \\\"bg_color_2\\\": rconfd[\\\"bg_color_2\\\"]})\\n\\n # Extract droplet geometry\\n # convert_data.conv_ply(h5dns_path=cconfd[\\\"h5dns_path\\\"], output_dir=geometry_output_dir, tres=int(cconfd[\\\"tres\\\"]))\\n\\n # Extract lambda2 contour geometry\\n convert_data.conv_lambda2_ply(h5dns_path=cconfd[\\\"h5dns_path\\\"], output_dir=ply_lambda2_output_dir, tres=cconfd[\\\"tres\\\"], contour_level=lambda2_level)\\n\\n # Launch Blender to perform rendering\\n blender_launcher.launch_blender_new(blender_config_filedir=blender_config_filedir, python_name=\\\"droplet_render.py\\\", blend_name=\\\"droplet_render.blend\\\")\",\n \"def compile_tuning(self, cf):\\n logger = self._logger\\n for s in cf.sections():\\n logger.debug('Collecting definitions for %s', s)\\n try:\\n rexp = cf.get(s, 'regex')\\n except ConfigParser.NoOptionError:\\n self._logger.error('Section \\\"%s\\\" missing \\\"regex\\\" option', s)\\n continue\\n try:\\n r = re.compile(rexp)\\n except:\\n self._logger.error('Section \\\"%s\\\" invalid \\\"regex\\\" option', s)\\n continue\\n try:\\n transfer = cf.getint(s, 'transfer')\\n except ConfigParser.NoOptionError:\\n self._logger.info('Section \\\"%s\\\" missing \\\"transfer\\\" option', s)\\n transfer = 512\\n except ValueError:\\n self._logger.error('Section \\\"%s\\\", \\\"transfer\\\" option must be integer', s)\\n continue\\n try:\\n readahead = cf.getint(s, 'readahead')\\n except ConfigParser.NoOptionError:\\n self._logger.info('Section \\\"%s\\\" missing \\\"readahead\\\" option', s)\\n readahead = 2*transfer\\n except ValueError:\\n self._logger.error('Section \\\"%s\\\", \\\"readahead\\\" option must be integer', s)\\n continue\\n try:\\n scheduler = cf.get(s, 'scheduler')\\n except ConfigParser.NoOptionError:\\n self._logger.info('Section \\\"%s\\\" missing \\\"scheduler\\\" option', s)\\n scheduler = None\\n opts = []\\n if scheduler == 'deadline':\\n opts = []\\n for deadOpt in ('fifo_batch', 'read_expire', 'write_expire', 'writes_starved', 'front_merges'):\\n try:\\n deadVal = cf.getint(s, deadOpt)\\n except ConfigParser.NoOptionError:\\n self._logger.info('Section \\\"%s\\\" missing \\\"%s\\\" option', s, deadOpt)\\n deadVal = None\\n except ValueError:\\n self.logger.error('Section \\\"%s\\\", \\\"%s\\\" option must be integer', s, deadOpt)\\n continue\\n opts += [ deadVal ]\\n self._lunMatch.append( ( r, transfer, readahead, scheduler, opts ) )\",\n \"def merge_configs(configFile:str, oldSampleFile:str, newSampleFile:str, unsafeAttributesFile:str, filetype:str):\\n upgrade_config(configFile, oldSampleFile, newSampleFile, unsafeAttributesFile, filetype)\",\n \"def create(self):\\n\\n for key in self.dirs.keys():\\n if type(self.dirs[key]) == dict:\\n for dir_type in self.dirs[key].keys():\\n create_if_not_exists(self.dirs[key][dir_type])\\n else:\\n create_if_not_exists(self.dirs[key])\\n\\n # read the file in, sample-by-sample\\n # build the dictionary recursively\\n # add rle file also to generated cfg files\\n # print integrations per job as well!\\n # consider more than 1 file per jobs -- the jobs are splitted by MEM integration anyways\\n\\n rle_filters = self.get_filter() if self.rle_filter_file else {}\\n statistics = {}\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"]:\\n continue\\n\\n if not os.path.exists(sample_info['local_paths'][0]['path']):\\n logging.warning(\\\"Skipping sample {sample_name}\\\".format(sample_name = sample_name))\\n continue\\n\\n process_name = sample_info[\\\"process_name_specific\\\"]\\n logging.info(\\\"Creating configuration files to run '%s' for sample %s\\\" % (self.executable_addMEM, process_name))\\n is_mc = (sample_info[\\\"type\\\"] == \\\"mc\\\")\\n if self.rle_filter_file:\\n assert(process_name in rle_filters)\\n\\n inputFileList = generateInputFileList(sample_info, self.max_files_per_job)\\n # typically, the analysis ends here and starts looping b/c the smallest unit of work processes\\n # at least one file; we need, however, to split the file into event ranges in such a way that\\n # each job performs mem_integrations_per_job MEM integrations\\n\\n # so what we are going to do is to open each set of files in inputFileList, read the variable\\n # requestMEM_*l_*tau and try to gather the event ranges such that each event range\\n # performs up to mem_integrations_per_job integrations per job\\n memEvtRangeDict = self.memJobList(inputFileList, rle_filters[process_name] if self.rle_filter_file else [])\\n\\n for jobId in memEvtRangeDict.keys():\\n\\n key_dir = getKey(sample_name)\\n key_file = getKey(sample_name, jobId)\\n\\n self.inputFiles[key_file] = memEvtRangeDict[jobId]['input_fileset']\\n\\n # there should always be a job\\n assert(self.inputFiles[key_file] > 0), \\\"More than one input file: %s ?? !!\\\" % \\\\\\n ', '.join(self.inputFiles[key_file])\\n\\n #assert(len(self.inputFiles[key_file]) == 1), \\\"There is more than one input file!\\\"\\n self.cfgFiles_addMEM_modified[key_file] = os.path.join(\\n self.dirs[key_dir][DKEY_CFGS], \\\"addMEM_%s_%s_%i_cfg.py\\\" % (self.channel, process_name, jobId)\\n )\\n self.shFiles_addMEM_modified[key_file] = os.path.join(\\n self.dirs[key_dir][DKEY_CFGS], \\\"addMEM_%s_%s_%i.sh\\\" % (self.channel, process_name, jobId)\\n )\\n self.outputFiles[key_file] = os.path.join(\\n self.dirs[key_dir][DKEY_NTUPLES], \\\"%s_%i.root\\\" % (process_name, jobId)\\n )\\n self.logFiles_addMEM[key_file] = os.path.join(\\n self.dirs[key_dir][DKEY_LOGS], \\\"addMEM_%s_%s_%i.log\\\" % (self.channel, process_name, jobId)\\n )\\n self.logFiles_addMEM[key_file] = get_log_version((self.logFiles_addMEM[key_file],))[0]\\n self.createCfg_addMEM(\\n self.inputFiles[key_file],\\n memEvtRangeDict[jobId]['event_range'][0],\\n memEvtRangeDict[jobId]['event_range'][1],\\n self.outputFiles[key_file],\\n self.era,\\n sample_info[\\\"sample_category\\\"],\\n is_mc,\\n self.cfgFiles_addMEM_modified[key_file],\\n memEvtRangeDict[jobId]['whitelist'],\\n )\\n\\n # associate the output file with the fileset_id\\n #UDPATE: ONE OUTPUT FILE PER SAMPLE!\\n fileset_id = memEvtRangeDict[jobId]['fileset_id']\\n hadd_output_dir = os.path.join(\\n self.dirs[key_dir][DKEY_FINAL_NTUPLES],\\n '%04d' % (fileset_id // 1000)\\n )\\n if not os.path.exists(hadd_output_dir):\\n os.makedirs(hadd_output_dir)\\n hadd_output = os.path.join(\\n hadd_output_dir, '%s_%i.root' % ('tree', fileset_id) # UDPATE: ADDED\\n #hadd_output_dir, \\\"tree.root\\\" # UDPATE: REMOVED\\n )\\n if hadd_output not in self.hadd_records:\\n self.hadd_records[hadd_output] = {}\\n self.hadd_records[hadd_output]['output_files'] = []\\n self.hadd_records[hadd_output]['fileset_id'] = fileset_id\\n self.hadd_records[hadd_output]['output_files'].append(self.outputFiles[key_file])\\n self.hadd_records[hadd_output]['process_name'] = process_name\\n\\n # let's sum the number of integration per sample\\n nofEntriesMap = {}\\n for v in memEvtRangeDict.values():\\n if v['fileset_id'] not in nofEntriesMap:\\n nofEntriesMap[v['fileset_id']] = {\\n 'nof_entries' : v['nof_entries'],\\n }\\n statistics[process_name] = {\\n 'nof_int' : sum([entry['nof_int'] for entry in memEvtRangeDict.values()]),\\n 'nof_entries' : sum([entry['nof_entries'] for entry in nofEntriesMap.values()]),\\n 'nof_events_pass' : sum([entry['nof_events_pass'] for entry in memEvtRangeDict.values()]),\\n 'nof_int_pass' : sum([entry['nof_int_pass'] for entry in memEvtRangeDict.values()]),\\n 'nof_zero' : sum([entry['nof_zero'] for entry in memEvtRangeDict.values()]),\\n 'nof_jobs' : len(memEvtRangeDict),\\n }\\n\\n if self.is_sbatch:\\n logging.info(\\\"Creating script for submitting '%s' jobs to batch system\\\" % self.executable_addMEM)\\n self.createScript_sbatch()\\n\\n logging.info(\\\"Creating Makefile\\\")\\n lines_makefile = []\\n self.addToMakefile_addMEM(lines_makefile)\\n self.addToMakefile_hadd(lines_makefile)\\n self.createMakefile(lines_makefile)\\n\\n ws_len = max([len(kk) + 1 for kk in statistics.keys()])\\n total_nof_integrations_sum = sum(x['nof_int'] for x in statistics.values())\\n total_nof_entires = sum(x['nof_entries'] for x in statistics.values())\\n total_nof_zero_int = sum(x['nof_zero'] for x in statistics.values())\\n total_nof_jobs = sum(x['nof_jobs'] for x in statistics.values())\\n total_nof_pass = sum(x['nof_events_pass'] for x in statistics.values())\\n total_nof_int_pass_avg = float(sum(x['nof_int_pass'] for x in statistics.values())) / total_nof_pass\\n total_nof_integrations_avg = float(total_nof_integrations_sum) / total_nof_entires\\n total_nof_int_per_job = float(total_nof_integrations_sum) / total_nof_jobs\\n for k, v in statistics.iteritems():\\n if v['nof_entries'] == 0:\\n int_per_event = 0.\\n evt_pass = 0.\\n else:\\n int_per_event = float(v['nof_int']) / v['nof_entries']\\n evt_pass = (100 * float(v['nof_events_pass']) / v['nof_entries'])\\n if v['nof_events_pass'] == 0:\\n nof_int_pass = 0.\\n else:\\n nof_int_pass = float(v['nof_int_pass']) / v['nof_events_pass']\\n print('%s%s: %d (%d entries; %d jobs; %.2f int/evt; %d (%.2f%%) evt pass; %.2f int/evt pass; %d evt 0int)' %\\n (k,\\n ' ' * (ws_len - len(k)),\\n v['nof_int'],\\n v['nof_entries'],\\n v['nof_jobs'],\\n int_per_event,\\n v['nof_events_pass'],\\n evt_pass,\\n nof_int_pass,\\n v['nof_zero'],\\n )\\n )\\n print('%s%s: %d (%d entries; %d jobs; %.2f int/evt; %d evt pass; %.2f int/evt pass; '\\n '%.2f int/job pass; %d evt 0int)' %\\n ('total',\\n ' ' * (ws_len - len('total')),\\n total_nof_integrations_sum,\\n total_nof_entires,\\n total_nof_jobs,\\n total_nof_integrations_avg,\\n total_nof_pass,\\n total_nof_int_pass_avg,\\n total_nof_int_per_job,\\n total_nof_zero_int,\\n )\\n )\\n\\n if self.max_mem_integrations > 0 and total_nof_integrations_sum > self.max_mem_integrations:\\n logging.error(\\\"Will not start the jobs (max nof integrations exceeded)!\\\")\\n return False\\n else:\\n logging.info(\\\"Done\\\")\\n return True\",\n \"def build_config(self, config):\\n \\n config.setdefaults(\\n 'Network', {'IP': '192.168.1.16', 'port': 8000}\\n )\\n config.setdefaults(\\n 'Camera', {'ISO': 100, 'Shutter': 5000, 'Aperture': 4, 'Zoom': 45}\\n )\\n config.setdefaults(\\n 'Admin', {'Logging Path': gs.AUVSI_BASE_FOLDER}\\n )\\n config.setdefaults(\\n 'CV', {'image_rescaling': 0.25}\\n )\\n \\n #\\n # Disable multi touch emulation with the mouse.\\n #\\n from kivy.config import Config\\n Config.set('input', 'mouse', 'mouse,disable_multitouch')\",\n \"def set_filter():\\n try:\\n #=======================================================================\\n # isofilter=[arg.partition('=')[-1] for arg in argv if 'atomfilter=' in arg][0][1:-1].split(',')\\n #=======================================================================\\n isofilter = config.arg('atomfilter')[1:-1].split(',')\\n isofilter = [f.split(':') for f in isofilter]\\n for f in isofilter:\\n if len(f) < 2:\\n f.append('True')\\n if len(f) < 3:\\n f.append('True')\\n if len(f) < 4:\\n f.append('None')\\n except:\\n isofilter = [['element', 'H', 'True', 'None']]\\n try:\\n #=======================================================================\\n # isopartnerfilter=[arg.partition('=')[-1] for arg in argv if 'partnerfilter=' in arg][0][1:-1].split(',')\\n #=======================================================================\\n isopartnerfilter = config.arg('partnerfilter')[1:-1].split(',')\\n isopartnerfilter = [f.split(':') for f in isopartnerfilter]\\n for f in isopartnerfilter:\\n if len(f) < 2:\\n f.append('True')\\n if len(f) < 3:\\n f.append('True')\\n if len(f) < 4:\\n f.append('None')\\n except:\\n isopartnerfilter = [['None', 'None', 'None', 'None']]\\n return isofilter, isopartnerfilter\\n isofilterlist = []\\n isopartnerfilterlist = []\\n for i in xrange(len(isofilter) / 2):\\n isofilterlist.append(tuple(isofilter[2 * i:2 * i + 2]))\\n for i in xrange(len(isopartnerfilter) / 2):\\n isopartnerfilterlist.append(tuple(isopartnerfilter[2 * i:2 * i + 2]))\\n\\n return [isofilterlist, isopartnerfilterlist]\",\n \"def config( **kwargs ):\",\n \"def filter(self, filters):\",\n \"def configure(config_file):\\n Config.config_file = config_file\\n config = ConfigParser()\\n config.optionxform = str\\n config.read(config_file)\\n dct = {}\\n for item in list(config.sections()):\\n dct[item] = dict(config.items(item))\\n\\n for item in dct.keys():\\n if item == 'config':\\n for key in dct[item].keys():\\n dct[item][key] = tf(dct[item][key])\\n\\n if item == 'continuum':\\n for key, val in dct[item].items():\\n val = val.split(',')\\n if len(val) == 2:\\n dct[item][key] = {'xlim': float(val[0]), 'ylim': float(val[1])}\\n dct[item][key] = {'ylim': float(val[0])}\\n else:\\n for k in [\\\"N\\\", \\\"b\\\", \\\"z\\\"]:\\n try:\\n dct[item][k] = dct[item][k].replace(\\\" \\\", \\\"\\\")\\n dct[item][k] = list(map(float, dct[item][k].strip().split(',')))\\n except KeyError:\\n pass\\n\\n cond = []\\n if \\\"N\\\" in dct[item].keys():\\n cond += [dct[item][\\\"N\\\"][0] < 10., dct[item][\\\"N\\\"][-1] > 23.,\\n dct[item][\\\"N\\\"][-1] < dct[item][\\\"N\\\"][0]]\\n\\n if \\\"b\\\" in dct[item].keys():\\n cond += [dct[item][\\\"b\\\"][0] < 0., dct[item][\\\"b\\\"][-1] < dct[item][\\\"b\\\"][0]]\\n\\n if \\\"z\\\" in dct[item].keys():\\n cond += [dct[item][\\\"z\\\"][-1] < dct[item][\\\"z\\\"][0]]\\n\\n if any(cond):\\n raise Exception(\\\"check your random sampling inputs\\\")\\n\\n set_config_defaults(dct)\\n _set_values(dct)\",\n \"def apply_configs(task):\\n\\n if \\\"3750X\\\" in task.host[\\\"sw_model\\\"]:\\n # run 3750X function\\n aaa_3750x(task)\\n\\n # apply global config file for each host\\n task.run(task=napalm_configure, filename=f\\\"configs/{task.host}_dot1x_global.txt\\\")\\n # print completed hosts\\n c_print(f\\\"*** {task.host}: dot1x global configuration applied ***\\\")\\n # apply snmp config file for each host\\n task.run(task=napalm_configure, filename=f\\\"configs/{task.host}_snmp.txt\\\")\\n # print completed hosts\\n c_print(f\\\"*** {task.host}: SNMP configuration applied ***\\\")\\n # apply interface config file for each host\\n task.run(task=napalm_configure, filename=f\\\"configs/{task.host}_dot1x_intf.txt\\\")\\n # print completed hosts\\n c_print(f\\\"*** {task.host}: dot1x interface configuration applied ***\\\")\",\n \"def configure(self, env, check=False):\\n conf = env.Configure(custom_tests=self.customTests)\\n for name, module in self.packages.items():\\n if module is None:\\n state.log.info(f\\\"Skipping missing optional package {name}.\\\")\\n continue\\n if not module.config.configure(conf, packages=self.packages, check=check, build=False):\\n state.log.fail(f\\\"{name} was found but did not pass configuration checks.\\\")\\n if self.primary:\\n self.primary.config.configure(conf, packages=self.packages, check=False, build=True)\\n env.AppendUnique(SWIGPATH=env[\\\"CPPPATH\\\"])\\n env.AppendUnique(XSWIGPATH=env[\\\"XCPPPATH\\\"])\\n # reverse the order of libraries in env.libs, so libraries that\\n # fulfill a dependency of another appear after it. required by the\\n # linker to successfully resolve symbols in static libraries.\\n for target in env.libs:\\n env.libs[target].reverse()\\n env = conf.Finish()\\n return env\",\n \"def on_game_start(self, config):\\n gamelib.debug_write('Configuring your custom algo strategy...')\\n self.config = config\\n global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER\\n FILTER = config[\\\"unitInformation\\\"][0][\\\"shorthand\\\"]\\n ENCRYPTOR = config[\\\"unitInformation\\\"][1][\\\"shorthand\\\"]\\n DESTRUCTOR = config[\\\"unitInformation\\\"][2][\\\"shorthand\\\"]\\n PING = config[\\\"unitInformation\\\"][3][\\\"shorthand\\\"]\\n EMP = config[\\\"unitInformation\\\"][4][\\\"shorthand\\\"]\\n SCRAMBLER = config[\\\"unitInformation\\\"][5][\\\"shorthand\\\"]\\n self.structureInPlace = False\\n self.destructorsLeft = 0\\n self.destructorsMiddle = 0\\n self.juicyTargets = 0\\n self.juicyCorner = False\\n self.floodGatesOpen = True\\n self.defenseRating = 0\\n self.defenseCost = 0\\n self.attackedFromLeft = 0\\n\\n self.mainStructure = [[ 25, 13],[ 24, 12],[ 23, 11],[ 22, 10],[ 21, 9],[ 20, 8],[ 19, 7],[ 18, 6],[ 17, 5],[ 16, 4],[ 15, 3],[ 14, 2],[ 13, 1]]\\n\\n\\n self.filter0 =[[ 0, 13],[ 1, 13],[ 2, 13],[ 3, 13],[ 4, 13],[ 5, 13],[ 6, 13],[ 7, 13],[ 8, 13],\\\\\\n [ 9, 13],[ 10, 13],[ 17, 13],[ 18, 13],[ 19, 13],[ 20, 13],[ 21, 13],[ 22, 13],[ 23, 13],[ 24, 13],[ 25, 13],[ 26, 13],[ 27, 13]] \\n self.filter1 = [[ 0, 13],[ 1, 13],[ 2, 13],[ 3, 13],[ 4, 13],[ 5, 13],[ 6, 13],[ 7, 13],[ 8, 13],[ 9, 13],[ 10, 13],[ 17, 13],\\\\\\n [ 18, 13],[ 19, 13],[ 20, 13],[ 21, 13],[ 22, 13],[ 23, 13],[ 24, 13],[ 25, 13],[ 26, 13],[ 27, 13],[ 2, 12],[ 25, 12],[ 3, 11],[ 24, 11],[ 4, 10]]\\n self.filter2 = [[ 0, 13],[ 1, 13],[ 2, 13],[ 3, 13],[ 4, 13],[ 5, 13],[ 6, 13],[ 7, 13],[ 8, 13],[ 9, 13],[ 10, 13],[ 17, 13],\\\\\\n [ 18, 13],[ 19, 13],[ 20, 13],[ 21, 13],[ 22, 13],[ 23, 13],[ 24, 13],[ 25, 13],[ 26, 13],[ 27, 13],[ 2, 12],[ 25, 12],[ 3, 11],[ 24, 11],[ 4, 10]]\\n self.filter3 = [[ 4, 13],[ 5, 13],[ 6, 13],[ 7, 13]]\\n\\n self.destructor0 = [[ 13, 13]]\\n self.destructor1 = [[ 13, 13],[ 14, 13]]\\n self.destructor2 = [[ 13, 13],[ 14, 13]]\\n self.destructor3 = [[ 13, 13],[ 14, 13]]\\n\\n self.initExclusionList = [[0,0]]\\n self.exclusionList = [[0,0]]\",\n \"def generateConfig(run,subrun,conditions):\\n \\n configname = (conditions.numcdir + \\\"/\\\" + str(run) + \\\"/\\\" + str(subrun)\\n + \\\"/numc_config_\\\" + str(run) + \\\"_\\\" + str(subrun) + \\\".cfg\\\")\\n \\n configContents = \\\"\\\"\\n \\n configContents += \\\"[software]\\\\n\\\"\\n if conditions.oldneut:\\n configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.1.4.2_nd280_ROOTv5r34p09n01/src/neutgeom/setup.sh\\\\n\\\"\\n elif conditions.newoldneut:\\n configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.1.4.3_nd280/src/neutgeom/setup.sh\\\\n\\\"\\n else:\\n #configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.3.1_nd280/src/neutgeom/setup.sh\\\\n\\\"\\n #configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.3.1_nd280_wBBBA05/src/neutgeom/setup.sh\\\\n\\\"\\n configContents += \\\"neut_setup_script = /project/t/tanaka/T2K/neut/branches/5.3.2_nd280/src/neutgeom/setup.sh\\\\n\\\"\\n \\n configContents += \\\"[geometry]\\\\n\\\"\\n\\n configContents += \\\"baseline = \\\" + conditions.geometry +\\\"\\\\n\\\"\\n if conditions.waterair == \\\"water\\\":\\n configContents += \\\"p0d_water_fill = 1\\\\n\\\"\\n else:\\n configContents += \\\"p0d_water_fill = 0\\\\n\\\"\\n \\n configContents += \\\"\\\"\\\"\\n \\n[configuration]\\nmodule_list = neutMC\\n\\n[filenaming]\\n\\\"\\\"\\\"\\n configContents += \\\"comment = \\\" + conditions.comment + \\\"\\\\n\\\"\\n configContents += \\\"run_number = \\\" + str(run) +\\\"\\\\n\\\"\\n configContents += \\\"subrun = \\\" + str(subrun) + \\\"\\\\n\\\"\\n\\n if conditions.oldneut:\\n configContents += \\\"\\\"\\\" \\n\\n[neutrino]\\nneut_card = /project/t/tanaka/T2K/neut/branches/5.1.4.2_nd280_ROOTv5r34p09n01/src/neutgeom/neut.card\\n\\\"\\\"\\\"\\n elif conditions.newoldneut:\\n configContents += \\\"\\\"\\\" \\n\\n[neutrino]\\nneut_card = /project/t/tanaka/T2K/neut/branches/5.1.4.3_nd280/src/neutgeom/neut.card\\n\\\"\\\"\\\"\\n else:\\n configContents += \\\"\\\"\\\" \\n\\n[neutrino]\\nneut_card = /project/t/tanaka/T2K/neut/branches/5.3.2_nd280/src/neutgeom/neut.card\\n\\\"\\\"\\\"\\n\\n configContents += \\\"flux_file = \\\" + conditions.ram_disk + \\\"/\\\" + conditions.flux_base + \\\"\\\\n\\\"\\n\\n#flux_file = flux_file\\n#\\\"\\\"\\\"\\n\\n# configContents += \\\"flux_file_path = \\\" + conditions.ram_disk + \\\"/\\\" + conditions.flux_base\\n\\n# configContents += \\\"\\\"\\\" \\n#flux_file_start = 1\\n#flux_file_stop = 300\\n#\\\"\\\"\\\"\\n\\n configContents += \\\"maxint_file = \\\" + conditions.maxint_file_local + \\\"\\\\n\\\"\\n\\n# default: 5e17 but for basket MC special production higher\\n configContents += \\\"\\\"\\\" \\npot = 5.0e17\\nneutrino_type = beam\\n\\\"\\\"\\\"\\n if conditions.baskmagn == \\\"basket\\\":\\n configContents += \\\"\\\"\\\" \\nflux_region = basket\\nmaster_volume = Basket \\nrandom_start = 1\\n\\\"\\\"\\\"\\n elif conditions.baskmagn == \\\"magnet\\\":\\n configContents += \\\"\\\"\\\" \\nflux_region = magnet\\nmaster_volume = Magnet \\nrandom_start = 1\\n\\\"\\\"\\\"\\n else:\\n print \\\"Unknown basket/magnet condition\\\"\\n \\n\\n configContents += \\\"random_seed = \\\" + str(getRandom()) +\\\"\\\\n\\\"\\n configContents += \\\"neut_seed1 = \\\" + str(getRandom())+\\\"\\\\n\\\" \\n configContents += \\\"neut_seed2 = \\\" + str(getRandom())+\\\"\\\\n\\\" \\n configContents += \\\"neut_seed3 = \\\" + str(getRandom())+\\\"\\\\n\\\" \\n\\n configContents += \\\"\\\\n\\\"\\n configContents += \\\"[nd280mc]\\\\n\\\"\\n configContents += \\\"mc_type=Neut_RooTracker \\\\n\\\"\\n\\n #print configContents\\n\\n try:\\n macFile = open(configname,\\\"w\\\")\\n macFile.write(configContents)\\n \\n except:\\n print \\\"can't write config file\\\" \\n \\n\\n return configname\",\n \"def config(\\n data_folder=settings.data_folder,\\n logs_folder=settings.logs_folder,\\n imgs_folder=settings.imgs_folder,\\n cache_folder=settings.cache_folder,\\n cache_responses=settings.cache_responses,\\n log_file=settings.log_file,\\n log_console=settings.log_console,\\n log_level=settings.log_level,\\n log_name=settings.log_name,\\n log_filename=settings.log_filename,\\n useful_idf_objects=settings.useful_idf_objects,\\n default_weight_factor=\\\"area\\\",\\n ep_version=settings.ep_version,\\n debug=settings.debug,\\n):\\n # set each global variable to the passed-in parameter value\\n settings.cache_responses = cache_responses\\n settings.cache_folder = Path(cache_folder).expand().makedirs_p()\\n settings.data_folder = Path(data_folder).expand().makedirs_p()\\n settings.imgs_folder = Path(imgs_folder).expand().makedirs_p()\\n settings.logs_folder = Path(logs_folder).expand().makedirs_p()\\n settings.log_console = log_console\\n settings.log_file = log_file\\n settings.log_level = log_level\\n settings.log_name = log_name\\n settings.log_filename = log_filename\\n settings.useful_idf_objects = useful_idf_objects\\n settings.zone_weight.set_weigth_attr(default_weight_factor)\\n settings.ep_version = ep_version\\n settings.debug = debug\\n\\n # if logging is turned on, log that we are configured\\n if settings.log_file or settings.log_console:\\n get_logger(name=\\\"archetypal\\\")\\n log(\\\"Configured archetypal\\\")\",\n \"def load_filters(self, filters):\\n if not filters:\\n return\\n if not isinstance(filters, list):\\n raise errors.ParserError(\\\"Expecting 'filters' value to be a list \\\"\\n \\\"but instead its a {}.\\\".format(type(filters)))\\n for filter_path in filters:\\n if not os.path.exists(filter_path):\\n raise errors.ParserError(\\n \\\"Filter path '{}' doesn't exist\\\".format(filter_path))\\n elif os.path.isdir(filter_path):\\n self._load_filter_directory(filter_path)\\n else:\\n self.load_filter_file(filter_path)\",\n \"def _build_pipeline(\\n self, cfg: Dict, domain_file: Text\\n ) -> List[Policy]:\\n\\n pipeline = []\\n\\n for i in cfg['policies']:\\n policy_name=i['name']\\n policy=registered_policies[policy_name](domain_file)\\n pipeline.append(policy)\\n\\n return pipeline\",\n \"def includeme(config):\",\n \"def setupconfig():\\n from Manager import Studio\\n studio = Studio.Instance\\n cfgeff = studio.configEffect_st\\n cfgeff.bloomToggle.isOn = False\\n cfgeff.vignetteToggle.isOn = False\\n cfgeff.sunShaftsToggle.isOn = False\\n cfgeff.fogToggle.isOn = False\\n cfgeff.depthOfFieldToggle.isOn = False\\n #cfgeff.ssaoToggle.isOn = True\\n #cfgeff.selfShadowToggle.isOn = True\\n \\n # Turn off backgrounds\\n studio.uiBGChanger.onOffToggle.isOn = False\",\n \"def setup_config_folder(self):\\n\\n config_dir = self.config_folder\\n \\n logging.info(\\\"using config folder: %s\\\" % (config_dir))\\n if not os.path.isdir(config_dir):\\n os.mkdir(config_dir)\\n\\n try:\\n f = open(config_dir + self.wordlist_file,'r')\\n except IOError:\\n f = open(config_dir + self.wordlist_file,'a+')\\n f.close()\\n\\n try:\\n f = open(config_dir + self.score_file,'r')\\n except IOError:\\n f = open(config_dir + self.score_file,'a+')\\n f.close()\",\n \"def init_config(self):\\n pass\",\n \"def __init__(self, prod_obj, log_level=logutil.logging.NOTSET, use_defaults=True, input_custom_pars_file=None,\\n output_custom_pars_file=None):\\n log.setLevel(log_level)\\n if input_custom_pars_file and input_custom_pars_file and input_custom_pars_file == output_custom_pars_file:\\n sys.exit(\\\"ERROR: Input and output parameter files must have unique names!\\\")\\n self.label = \\\"hap_config\\\"\\n self.description = \\\"A set of routines to generate appropriate set of configuration parameters\\\"\\n self.instrument = prod_obj.instrument\\n self.detector = prod_obj.detector\\n self.inst_det = \\\"{}_{}\\\".format(prod_obj.instrument, prod_obj.detector).lower()\\n self.use_defaults = use_defaults\\n self.input_custom_pars_file = input_custom_pars_file\\n self.output_custom_pars_file = output_custom_pars_file\\n\\n # The filters attribute is populated by _determine_conditions()\\n self.filters = None\\n\\n self._determine_conditions(prod_obj)\\n self.full_cfg_index, self.pars_dir = read_index(self.instrument,\\n self.detector)\\n\\n # Instantiate the parameter set\\n self.pars = {}\\n\\n # open input parameter file if specified by user\\n if self.input_custom_pars_file:\\n with open(self.input_custom_pars_file) as f_cfg:\\n self.input_cfg_json_data = json.load(f_cfg)[prod_obj.product_basename]\\n else:\\n self.input_cfg_json_data = None\\n\\n # generate parameter sets for each pipeline step\\n # step_name_list = [AstrodrizzlePars, CatalogGenerationPars, QualityControlPars]\\n # step_title_list = ['astrodrizzle', 'catalog generation', 'quality control']\\n for step_title, step_name in zip(step_title_list, step_name_list):\\n cfg_index = self.full_cfg_index[step_title]\\n self.pars[step_title] = step_name(cfg_index,\\n self.conditions,\\n self.pars_dir,\\n step_title,\\n self.use_defaults,\\n self.input_cfg_json_data)\\n\\n # write out all parameters to file if specified by user\\n if output_custom_pars_file:\\n self.write_pars(prod_obj)\",\n \"def buildRegFilterList(self, filename, listname='regFilterList'):\",\n \"def setup(args):\\n cfg = get_cfg()\\n add_imaterialist_config(cfg)\\n cfg.merge_from_file(model_zoo.get_config_file(\\\"COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml\\\"))\\n cfg.merge_from_file(args.config_file)\\n \\n cfg.merge_from_list(args.opts)\\n cfg.freeze()\\n default_setup(cfg, args)\\n # Setup logger for \\\"imaterialist\\\" module\\n setup_logger(output=cfg.OUTPUT_DIR, distributed_rank=comm.get_rank(), name=\\\"imaterialist\\\")\\n return cfg\",\n \"def create_config(self) -> None:\\n pass\",\n \"def create_config(self) -> None:\\n pass\",\n \"def config_create():\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n global CONSUMER_KEY \\r\\n global CONSUMER_SECRET \\r\\n global ACCESS_KEY \\r\\n global ACCESS_SECRET\\r\\n global TweetBotName \\r\\n global StreamL \\r\\n global TweetL \\r\\n global NSFW \\r\\n global SFW \\r\\n global searchterm \\r\\n global tMax \\r\\n global tMin \\r\\n global tStep\\r\\n \\r\\n config = configparser.ConfigParser()\\r\\n with open('botconfig.ini', 'r') as configfile:\\r\\n config.read_file(configfile)\\r\\n CONSUMER_KEY = config.get('Auth', 'CONSUMER_KEY') \\r\\n CONSUMER_SECRET = config.get('Auth', 'CONSUMER_SECRET').encode('utf-8') \\r\\n ACCESS_KEY = config.get('Auth', 'ACCESS_KEY').encode('utf-8')\\r\\n ACCESS_SECRET = config.get('Auth', 'ACCESS_SECRET').encode('utf-8')\\r\\n TweetBotName = config.get('Auth', 'BotName')\\r\\n StreamL = config.get('Log', 'Log1')\\r\\n TweetL = config.get('Log', 'Log2')\\r\\n NSFW = config.get('Filter', 'String1')\\r\\n SFW = config.get('Filter', 'String2')\\r\\n searchterm = config.get('Filter', 'Search')\\r\\n tMax = int(float(config.get('Tweet_Delay', 'Max')))\\r\\n tMin = int(float(config.get('Tweet_Delay', 'Min')))\\r\\n tStep = int(float(config.get('Tweet_Delay', 'Step')))\\r\\n global api \\r\\n\\r\\n \\\"\\\"\\\"\\r\\n config = configparser.ConfigParser()\\r\\n with open('botconfig.ini', 'r') as configfile:\\r\\n config.readfp(configfile)\\r\\n return config\",\n \"def _configure_addon(self):\\n cfg = None\\n try:\\n data_dir = os.path.split(self.props.data_dir)\\n\\n cfg = Configuration(jobtype='Blender', \\n data_path=data_dir[0],\\n log_level=int(self.props.log_level),\\n name=self.props.ini_file,\\n datadir=data_dir[1])\\n \\n except (InvalidConfigException, IndexError) as exp:\\n self.log.warning(\\\"Warning failed to load config file, \\\"\\n \\\"creating new default config.\\\")\\n self.log.warning(str(exp))\\n \\n finally:\\n\\n if not os.path.isdir(self.props.data_dir):\\n raise EnvironmentError(\\\"Data directory not created - \\\"\\n \\\"please ensure you have adequate permissions.\\\")\\n\\n if not cfg:\\n cfg = Configuration(jobtype='Blender', log_level='warning')\\n\\n if self.props.endpoint:\\n cfg = override_config(cfg, endpoint=self.props.endpoint)\\n if self.props.account:\\n cfg = override_config(cfg, account=self.props.account)\\n if self.props.key:\\n cfg = override_config(cfg, key=self.props.key)\\n if self.props.client_id:\\n cfg = override_config(cfg, client_id=self.props.client_id)\\n if self.props.tenant:\\n cfg = override_config(cfg, tenant=self.props.tenant)\\n if self.props.redirect:\\n cfg = override_config(cfg, redirect=self.props.redirect)\\n\\n cfg.save_config()\\n return cfg\",\n \"def configuration():\",\n \"def configuration(config):\\n create_str_dir(config)\\n add_skymap(config)\\n save_configuration(config)\",\n \"def _add_filters(self, filter_list, filter_path):\\n if not isinstance(filter_list, list):\\n raise errors.ParserError(\\n \\\"Loading filter-file {} failed. \\\"\\n \\\"Expecting value of 'filter_list' entry to be a list \\\"\\n \\\"but instead its a {}.\\\".format(filter_path, type(filter_list)))\\n\\n for cur_filter in filter_list:\\n self._add_filter(cur_filter, filter_path)\",\n \"def add_filters(fnames):\\n with Database(writable=True) as base:\\n for fname in fnames:\\n with open(fname, 'r') as f_fname:\\n filter_name = f_fname.readline().strip('# \\\\n\\\\t')\\n filter_type = f_fname.readline().strip('# \\\\n\\\\t')\\n filter_description = f_fname.readline().strip('# \\\\n\\\\t')\\n filter_table = np.genfromtxt(fname)\\n # The table is transposed to have table[0] containing the\\n # wavelength and table[1] containing the transmission.\\n filter_table = filter_table.transpose()\\n # We convert the wavelength from Å to nm.\\n filter_table[0] *= 0.1\\n\\n print(\\\"Importing {}... ({} points)\\\".format(filter_name,\\n filter_table.shape[1]))\\n\\n new_filter = Filter(filter_name, filter_description, filter_type,\\n filter_table)\\n\\n # We normalise the filter and compute the effective wavelength.\\n # If the filter is a pseudo-filter used to compute line fluxes, it\\n # should not be normalised.\\n if not filter_name.startswith('PSEUDO'):\\n new_filter.normalise()\\n else:\\n new_filter.effective_wavelength = np.mean(\\n filter_table[0][filter_table[1] > 0]\\n )\\n\\n base.add_filter(new_filter)\",\n \"def main():\\n if len(sys.argv) != 2:\\n print('USAGE:\\\\tpython3 inoti_make.py <CONFIG_FILE>')\\n exit(1)\\n config = parse(sys.argv[1])\\n listen_folders(config)\",\n \"def __init__(self, config_file: str | None = None) -> None:\\n self.found_deprecations: list[str] = []\\n self.default_config_file = str(\\n importlib.resources.files(\\\"bandersnatch\\\") / \\\"default.conf\\\"\\n )\\n self.config_file = config_file\\n self.load_configuration()\\n # Keeping for future deprecations ... Commenting to save function call etc.\\n # self.check_for_deprecations()\",\n \"def test_process_library_filter_removes_duplicates(self) -> None:\\n import hammer_config\\n\\n tech_dir, tech_dir_base = HammerToolTestHelpers.create_tech_dir(\\\"dummy28\\\")\\n tech_json_filename = os.path.join(tech_dir, \\\"dummy28.tech.json\\\")\\n\\n def add_duplicates(in_dict: Dict[str, Any]) -> Dict[str, Any]:\\n out_dict = deepdict(in_dict)\\n out_dict[\\\"libraries\\\"].append({\\n \\\"name\\\": \\\"abcdef\\\",\\n \\\"gds file\\\": \\\"test/abcdef.gds\\\"\\n })\\n out_dict[\\\"libraries\\\"].append({\\n \\\"name\\\": \\\"abcdef2\\\",\\n \\\"gds file\\\": \\\"test/abcdef.gds\\\"\\n })\\n return out_dict\\n\\n HammerToolTestHelpers.write_tech_json(tech_json_filename, add_duplicates)\\n sys.path.append(tech_dir_base)\\n tech = self.get_tech(hammer_tech.HammerTechnology.load_from_dir(\\\"dummy28\\\", tech_dir))\\n tech.cache_dir = tech_dir\\n\\n database = hammer_config.HammerDatabase()\\n tech.set_database(database)\\n outputs = tech.process_library_filter(pre_filts=[], filt=hammer_tech.filters.gds_filter,\\n must_exist=False,\\n output_func=lambda str, _: [str])\\n\\n self.assertEqual(outputs, [\\\"{0}/abcdef.gds\\\".format(tech_dir)])\\n\\n # Cleanup\\n shutil.rmtree(tech_dir_base)\",\n \"def apply(self) -> None:\\n _ba.apply_config()\",\n \"def _setup_configfiles(self, Testboard):\\n\\n # Delete all root files which are already in the directory\\n root_files = glob.glob(Testboard.testdir+'/*.root')\\n for f in root_files:\\n os.remove(f)\\n # Change testboard name\\n\\tif Testboard.DTB and os.path.isfile(Testboard.testdir + \\\"/tb\\\"):\\n self._config_file_content_substitute(Testboard.testdir + \\\"/tb\\\", {\\\"id\\\":Testboard.address})\\n else:\\n self._config_file_content_substitute(Testboard.testdir + \\\"/configParameters.dat\\\", {\\\"testboardName\\\":Testboard.address})\\n\\n # Get test specific config parameters (if available)\\n params = ()\\n try:\\n params = self.init.items(\\\"Test \\\" + self.test.testname)\\n except:\\n return\\n for par in params:\\n file = par[0]\\n if '.cfg' in file:\\n section,pair = par[1].split(':')\\n key,value = pair.split('=')\\n config_file = BetterConfigParser()\\n config_file.read(Testboard.testdir + \\\"/\\\" + file)\\n config_file.set(section,key,value)\\n write_file = open(Testboard.testdir + \\\"/\\\" + file, 'write')\\n config_file.write(write_file)\\n write_file.close()\\n continue\\n # Check for valid keys that represent config files\\n elif \\\"testParameters\\\" in file or \\\"dacParameters\\\" in file or \\\"configParameters\\\" in file:\\n pass\\n elif \\\"tbmParameters\\\" in file or \\\"tbParameters\\\" in file:\\n pass\\n else:\\n continue\\n\\n encoded_keys = par[1].split(\\\",\\\")\\n keys = {}\\n for key in encoded_keys:\\n key = key.split(\\\"=\\\", 2)\\n if len(key) != 2:\\n continue\\n keys[key[0]] = key[1]\\n if len(file) < 4 or file[-4:] != \\\".dat\\\":\\n file += \\\".dat\\\"\\n self._config_file_content_substitute(Testboard.testdir + \\\"/\\\" + file, keys)\",\n \"def defaultconfig(self):\\r\\n\\r\\n config_data = {\\r\\n \\\"path_to_database\\\": \\\"FUDB/FOLLOWUP.DB\\\",\\r\\n \\\"path_to_frontend\\\": \\\"FUDB/\\\",\\r\\n \\\"path_to_dcs_info\\\": \\\"FUDB/\\\",\\r\\n \\\"path_to_bin\\\": \\\"bin/\\\",\\r\\n \\\"path_to_excels_exported_from_database\\\": \\\"excels exported/\\\",\\r\\n \\\"path_to_excels_to_be_imported_in_database\\\": \\\"excels to be imported/\\\",\\r\\n \\\"path_to_new_opfiles\\\": \\\"DC BATCHES IN WORK/0 NEW/\\\",\\r\\n \\\"path_to_batches_unassigned\\\": \\\"DC BATCHES IN WORK/1 UNASSIGNED/\\\",\\r\\n \\\"path_to_batches_prepfiles\\\": \\\"DC BATCHES IN WORK/2 PREPARED FILES/\\\",\\r\\n \\\"path_to_batches_assigned\\\": \\\"DC BATCHES IN WORK/3 ASSIGNED/\\\",\\r\\n \\\"path_to_batches_tobechecked\\\": \\\"DC BATCHES IN WORK/4 TO BE CHECKED/\\\",\\r\\n \\\"path_to_batches_tbimported\\\": \\\"DC BATCHES IN WORK/5 TO BE IMPORTED/\\\",\\r\\n \\\"path_to_batches_finished\\\": \\\"DC BATCHES IN WORK/6 FINISHED/\\\",\\r\\n \\\"path_to_batches_instandby\\\": \\\"DC BATCHES IN WORK/7 IN STANDBY/\\\",\\r\\n \\\"path_to_batches_unrecordable\\\": \\\"DC BATCHES IN WORK/8 UNRECORDABLE/\\\",\\r\\n \\\"batch_status_options_responsible\\\": \\\"PREP. OP FILE, IMPORTATION & SPLIT FILE, RELIABILITY & DATA UPGRADE, CHECK OP FILE, CHECK SPLIT FILE, CHECK FRONT END, **TO BE CHECKED\\\",\\r\\n \\\"batch_status_options_proofreader\\\": \\\"OP FILE OK, SPLIT FILE OK, FRONT END OK, **TO BE IMPORTED, **FINISHED, **REWORK, **STANDBY, **UNRECORDABLE\\\",\\r\\n \\\"batch_status_options_overall\\\": \\\"ONGOING, STANDBY, FINISHED, UNRECORDABLE\\\",\\r\\n \\\"aircrafts\\\": \\\"A300, A300-600, A310, A320, A330, A340, A350, A380\\\",\\r\\n \\\"split_batch_factor\\\": \\\"2, 3, 4, 5, 6, 7, 8, 9\\\",\\r\\n \\\"IDlentgh\\\": \\\"6\\\",\\r\\n \\\"port\\\": \\\"5000\\\"\\r\\n }\\r\\n \\r\\n if not os.path.isfile(os.path.join(self.cwd, \\\"config.json\\\")):\\r\\n self.func.write_json(config_data, self.cwd, fname=\\\"config.json\\\")\",\n \"def _create(self):\\n super()._create()\\n \\n logging.info('Creating the spectral library configuration for file '\\n '{}'.format(self._filename))\\n\\n # read all the spectra in the spectral library\\n temp_info = collections.defaultdict(\\n lambda: {'id': [], 'precursor_mass': []})\\n offsets = {}\\n with self as lib_reader:\\n for spec, offset in tqdm.tqdm(lib_reader._get_all_spectra(),\\n desc='Library spectra read',\\n unit='spectra'):\\n # store the spectrum information for easy retrieval\\n info_charge = temp_info[spec.precursor_charge]\\n info_charge['id'].append(spec.identifier)\\n info_charge['precursor_mass'].append(spec.precursor_mz)\\n offsets[spec.identifier] = offset\\n self.spec_info = {'charge': {\\n charge: {\\n 'id': np.asarray(charge_info['id'], np.uint32),\\n 'precursor_mass': np.asarray(charge_info['precursor_mass'],\\n np.float32)\\n } for charge, charge_info in temp_info.items()}, 'offset': offsets}\\n\\n # store the configuration\\n config_filename = self._get_config_filename()\\n logging.debug('Saving the spectral library configuration to file '\\n '{}'.format(config_filename))\\n joblib.dump(\\n (os.path.basename(self._filename),\\n self.spec_info, self._config_hash),\\n config_filename, compress=9, protocol=pickle.DEFAULT_PROTOCOL)\\n\\n logging.info('Finished creating the spectral library configuration')\",\n \"def apply_filters(self, new_filters):\\n\\t\\tself.filters = new_filters\",\n \"def init_moscatel(filedir, filters_in_config, output_dir, skip_every=None):\\n file_list = glob(os.path.join(filedir,'*.fits'))\\n file_list.sort()\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n if os.listdir(filedir) != []:\\n #if len(file_list)>0:\\n print('total no. of raw data frames: {0}\\\\n'.format(len(file_list)))\\n\\n if skip_every is not None:\\n print('Skipping every {0}-th frames per band\\\\n'.format(skip_every))\\n\\n else: #elif skip_every == None:\\n '''\\n bug: does not print even if skip_every is not entered in terminal\\n '''\\n print('Analyzing all raw frames per band')\\n skip_every=1\\n\\n bands = {}\\n for j in filters_in_config:\\n j=j.strip(' ')\\n bands[j]=[]\\n filters_in_hdr=[]\\n\\n #get list of frames by filter based on header\\n for i in tqdm(file_list[::skip_every]):\\n hdr = pf.open(i)[0].header\\n filters_in_hdr.append(hdr['FILTER'])\\n for j in filters_in_config:\\n if hdr['FILTER'] == j:\\n j=j.strip(' ')\\n bands[j].append(i)\\n\\n filters_in_hdr_set=list(set(filters_in_hdr)).sort()\\n\\n for k in bands.keys():\\n print('{0}-band={1} frames'.format(k, len(bands[k])))\\n #save into txtfile\\n name = os.path.join(output_dir,k+'-band.txt')\\n with open(name, 'w') as z: #overwrite\\n #write line by line\\n for line in bands[k]:\\n z.write('{}\\\\n'.format(line))\\n print('\\\\nfilenames sorted by band saved in {}'.format(output_dir))\\n\\n else:\\n print('ERROR: check your data directory')\\n #return empty dict\\n bands={}\\n\\n return filters_in_hdr_set, bands\",\n \"def load_config(self):\\n pass\",\n \"def update_configs(self, config):\\n for what in self.plugins: # backend, repo etc.\\n for key in self.plugins[what]: # s3, filesystem etc.\\n # print(\\\"Updating configuration of\\\", what, key)\\n self.plugins[what][key].config(what='set', params=config)\\n return\",\n \"def _process_config(self, config):\\r\\n \\r\\n # test for colors following the naming conventions of matplotlib\\r\\n for k, v in config['colors'].items():\\r\\n try:\\r\\n mcolors.CSS4_COLORS[v]\\r\\n except KeyError:\\r\\n print(\\\"Color stated for '%s' does not exist! \\\\\\r\\n Choose color from: '%s'\\\" % \\r\\n (k, list(mcolors.CSS4_COLORS.keys())))\\r\\n else:\\r\\n self.colors[k] = v\\r\\n \\r\\n self.image = config['image']\\r\\n self.font = config['font']\\r\\n self.milestones = config['milestones']\\r\\n self.labels = config['labels']\",\n \"def apply_config(filename):\\n with open(filename) as config_file:\\n config = json.load(config_file)\\n for setting, value in config.items():\\n CoreConfig.__dict__[setting] = value\",\n \"def main(args):\\n\\n with open(args.cfg_fn, 'r') as cfg_fd:\\n config = cfg_fd.read().split(\\\"\\\\n\\\")\\n\\n with open(args.opt_fn, 'r') as opt_fd:\\n for oline in opt_fd:\\n option, value = oline.strip().split(\\\"=\\\")\\n\\n conf_addition = \\\"%s=%s\\\" % (option, value)\\n added = False\\n for line_nr, line in enumerate(config):\\n if \\\"# %s is not set\\\" % option in line or \\\\\\n \\\"%s=\\\" % option in line:\\n config[line_nr] = conf_addition\\n added = True\\n break\\n\\n if not added:\\n config.append(conf_addition)\\n\\n with open(args.cfg_fn, 'w') as cfg_fd:\\n cfg_fd.write(\\\"\\\\n\\\".join(config))\",\n \"def main(config):\\n file_paths_info = [('GLOFRIS','WATCH','ARG_inunriver_historical_000000000WATCH_1980_rp01000.tif'),\\n \\t\\t\\t\\t('GLOFRIS','RCP45','ARG_inunriver_rcp4p5_0000GFDL-ESM2M_2030_rp01000.tif'),\\n \\t\\t\\t\\t('GLOFRIS','RCP85','ARG_inunriver_rcp8p5_0000GFDL-ESM2M_2030_rp01000.tif'),\\n \\t\\t\\t\\t('FATHOM','AR_fluvial_undefended_merged','AR-FU-1000.tif'),\\n \\t\\t\\t\\t('FATHOM','AR_pluvial_undefended_merged','AR-PU-1000.tif')\\n \\t\\t\\t\\t]\\n figure_names = ['GLOFRIS-WATCH-fluvial','GLOFRIS-RCP45-fluvial','GLOFRIS-RCP85-fluvial','FATHOM-fluvial','FATHOM-pluvial']\\n figure_titles = ['current fluvial flooding','RCP4.5 fluvial flooding','RCP8.5 fluvial flooding','current fluvial flooding','current pluvial flooding']\\n for f_i in range(len(file_paths_info)):\\n\\t hazard_file = os.path.join(config['paths']['data'],'flood_data', file_paths_info[f_i][0],file_paths_info[f_i][1],file_paths_info[f_i][2])\\n\\t output_file = os.path.join(config['paths']['figures'], 'flood-map-{}.png'.format(figure_names[f_i]))\\n\\t ax = get_axes()\\n\\t plot_basemap(ax, config['paths']['data'])\\n\\t scale_bar(ax, location=(0.8, 0.05))\\n\\t plot_basemap_labels(ax, config['paths']['data'], include_regions=True,include_zorder=3)\\n\\n\\t proj_lat_lon = ccrs.PlateCarree()\\n\\n\\n\\t # Create color map\\n\\t colors = plt.get_cmap('Blues')\\n\\n\\t # Read in raster data\\n\\t data, lat_lon_extent = get_data(hazard_file)\\n\\t data[(data <= 0) | (data > 5)] = np.nan\\n\\t max_val = np.nanmax(data)\\n\\t norm=mpl.colors.Normalize(vmin=0, vmax=max_val)\\n\\n\\t # Plot population data\\n\\t im = ax.imshow(data, extent=lat_lon_extent,transform=proj_lat_lon, cmap=colors,norm =norm, zorder=2)\\n\\n\\t # Add colorbar\\n\\t cbar = plt.colorbar(im, ax=ax,fraction=0.1, shrink=0.87,pad=0.01, drawedges=False, orientation='horizontal',\\n\\t norm=mpl.colors.Normalize(vmin=0, vmax=max_val), ticks=list(np.linspace(0,max_val,3)))\\n\\t cbar.set_clim(vmin=0,vmax=max_val)\\n\\n\\n\\t cbar.outline.set_color(\\\"none\\\")\\n\\t cbar.ax.yaxis.set_tick_params(color='black')\\n\\t cbar.ax.set_xlabel('Flood depths (m)',fontsize=12,color='black')\\n\\n\\t plt.title('1 in 1000 year {}'.format(figure_titles[f_i]), fontsize = 14)\\n\\t save_fig(output_file)\\n\\t plt.close()\",\n \"def main(configs, outfile='Linker.json', verbose=False):\\n combined = {}\\n\\n for config in configs:\\n with open(config) as fd:\\n config_dict = json.load(fd)\\n combined.update(config_dict)\\n\\n if verbose:\\n print('\\\\n')\\n print(json.dumps(combined, indent=4, sort_keys=True))\\n\\n if verbose:\\n print('\\\\n')\\n print('wrote new linker file: ' + outfile)\\n json.dump(combined, open(outfile, 'w'), indent=4, sort_keys=True)\",\n \"def main():\\n processor.custom_config = parse_arguments()\\n processor.process()\\n logger.info(processor.statistics)\\n logger.info(processor.custom_config)\",\n \"def add_fixed_parameters_from_config_file(self, config_file):\\n pass\",\n \"def apply_settings():\\n\\n scs_globals = _get_scs_globals()\\n\\n # avoid recursion if another apply settings is running already\\n if scs_globals.config_update_lock:\\n return False\\n\\n # NOTE: save file paths in extra variables and apply them on the end\\n # to make sure all of the settings are loaded first.\\n # This is needed as some libraries reading are driven by other values from config file.\\n # For example: \\\"use_infixed\\\"\\n scs_project_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.scs_project_path, scs_globals)\\n shader_presets_filepath = _property_utils.get_by_type(bpy.types.GlobalSCSProps.shader_presets_filepath, scs_globals)\\n trigger_actions_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.trigger_actions_rel_path, scs_globals)\\n sign_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.sign_library_rel_path, scs_globals)\\n tsem_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.tsem_library_rel_path, scs_globals)\\n traffic_rules_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.traffic_rules_library_rel_path, scs_globals)\\n hookup_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.hookup_library_rel_path, scs_globals)\\n matsubs_library_rel_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.matsubs_library_rel_path, scs_globals)\\n sun_profiles_library_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.sun_profiles_lib_path, scs_globals)\\n conv_hlpr_converters_path = _property_utils.get_by_type(bpy.types.GlobalSCSProps.conv_hlpr_converters_path, scs_globals)\\n\\n # NOTE: as dump level is written in same section as config type\\n # applying it directly might take place before we get information about config type\\n # so it has to be saved into variable and applied only if global settings are loaded from config file\\n dump_level = scs_globals.dump_level\\n\\n # lock update now, as we don't want any properties update functions to trigger rewrite of config file\\n # which would lead to unwanted recursion\\n engage_config_lock()\\n\\n config_container = _pix.get_data_from_file(get_config_filepath(), \\\" \\\")\\n\\n # avoid applying process of config if not present (most probably permission problems on config creation)\\n if config_container is not None:\\n\\n settings_file_valid = 0\\n for section in config_container:\\n if settings_file_valid == 2:\\n if section.type == \\\"Paths\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"ProjectPath\\\":\\n scs_project_path = prop[1]\\n elif prop[0] == \\\"ShaderPresetsFilePath\\\":\\n shader_presets_filepath = prop[1]\\n elif prop[0] == \\\"TriggerActionsRelFilePath\\\":\\n trigger_actions_rel_path = prop[1]\\n elif prop[0] == \\\"TriggerActionsUseInfixed\\\":\\n scs_globals.trigger_actions_use_infixed = prop[1]\\n elif prop[0] == \\\"SignRelFilePath\\\":\\n sign_library_rel_path = prop[1]\\n elif prop[0] == \\\"SignUseInfixed\\\":\\n scs_globals.sign_library_use_infixed = prop[1]\\n elif prop[0] == \\\"TSemProfileRelFilePath\\\":\\n tsem_library_rel_path = prop[1]\\n elif prop[0] == \\\"TSemProfileUseInfixed\\\":\\n scs_globals.tsem_library_use_infixed = prop[1]\\n elif prop[0] == \\\"TrafficRulesRelFilePath\\\":\\n traffic_rules_library_rel_path = prop[1]\\n elif prop[0] == \\\"TrafficRulesUseInfixed\\\":\\n scs_globals.traffic_rules_library_use_infixed = prop[1]\\n elif prop[0] == \\\"HookupRelDirPath\\\":\\n hookup_library_rel_path = prop[1]\\n elif prop[0] == \\\"MatSubsRelFilePath\\\":\\n matsubs_library_rel_path = prop[1]\\n elif prop[0] == \\\"SunProfilesFilePath\\\":\\n sun_profiles_library_path = prop[1]\\n elif prop[0] == \\\"ConvertersPath\\\":\\n conv_hlpr_converters_path = prop[1]\\n elif prop[0] == \\\"UseAlternativeBases\\\":\\n scs_globals.use_alternative_bases = prop[1]\\n else:\\n lprint('W Unrecognised item \\\"%s\\\" has been found in setting file! Skipping...', (str(prop[0]),))\\n elif section.type == \\\"Import\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"ImportScale\\\":\\n scs_globals.import_scale = float(prop[1])\\n elif prop[0] == \\\"PreservePathForExport\\\":\\n scs_globals.import_preserve_path_for_export = prop[1]\\n elif prop[0] == \\\"ImportPimFile\\\":\\n scs_globals.import_pim_file = prop[1]\\n elif prop[0] == \\\"UseWelding\\\":\\n scs_globals.import_use_welding = prop[1]\\n elif prop[0] == \\\"WeldingPrecision\\\":\\n scs_globals.import_welding_precision = prop[1]\\n elif prop[0] == \\\"UseNormals\\\":\\n scs_globals.import_use_normals = prop[1]\\n elif prop[0] == \\\"ImportPitFile\\\":\\n scs_globals.import_pit_file = prop[1]\\n elif prop[0] == \\\"LoadTextures\\\":\\n scs_globals.import_load_textures = prop[1]\\n elif prop[0] == \\\"ImportPicFile\\\":\\n scs_globals.import_pic_file = prop[1]\\n elif prop[0] == \\\"ImportPipFile\\\":\\n scs_globals.import_pip_file = prop[1]\\n elif prop[0] == \\\"ImportPisFile\\\":\\n scs_globals.import_pis_file = prop[1]\\n elif prop[0] == \\\"ConnectedBones\\\":\\n scs_globals.import_connected_bones = prop[1]\\n elif prop[0] == \\\"BoneImportScale\\\":\\n scs_globals.import_bone_scale = float(prop[1])\\n elif prop[0] == \\\"ImportPiaFile\\\":\\n scs_globals.import_pia_file = prop[1]\\n elif prop[0] == \\\"IncludeSubdirsForPia\\\":\\n scs_globals.import_include_subdirs_for_pia = prop[1]\\n elif section.type == \\\"Export\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"ExportScale\\\":\\n scs_globals.export_scale = float(prop[1])\\n elif prop[0] == \\\"ApplyModifiers\\\":\\n scs_globals.export_apply_modifiers = prop[1]\\n elif prop[0] == \\\"ExcludeEdgesplit\\\":\\n scs_globals.export_exclude_edgesplit = prop[1]\\n elif prop[0] == \\\"IncludeEdgesplit\\\":\\n scs_globals.export_include_edgesplit = prop[1]\\n elif prop[0] == \\\"ActiveUVOnly\\\":\\n scs_globals.export_active_uv_only = prop[1]\\n elif prop[0] == \\\"ExportVertexGroups\\\":\\n scs_globals.export_vertex_groups = prop[1]\\n elif prop[0] == \\\"ExportVertexColor\\\":\\n scs_globals.export_vertex_color = prop[1]\\n elif prop[0] == \\\"ExportVertexColorType\\\":\\n scs_globals.export_vertex_color_type = str(prop[1])\\n elif prop[0] == \\\"ExportVertexColorType7\\\":\\n scs_globals.export_vertex_color_type_7 = str(prop[1])\\n elif prop[0] == \\\"ExportPimFile\\\":\\n scs_globals.export_pim_file = prop[1]\\n elif prop[0] == \\\"OutputType\\\":\\n scs_globals.export_output_type = prop[1]\\n elif prop[0] == \\\"ExportPitFile\\\":\\n scs_globals.export_pit_file = prop[1]\\n elif prop[0] == \\\"ExportPicFile\\\":\\n scs_globals.export_pic_file = prop[1]\\n elif prop[0] == \\\"ExportPipFile\\\":\\n scs_globals.export_pip_file = prop[1]\\n elif prop[0] == \\\"SignExport\\\":\\n scs_globals.export_write_signature = prop[1]\\n elif section.type == \\\"GlobalDisplay\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"DisplayLocators\\\":\\n scs_globals.display_locators = prop[1]\\n elif prop[0] == \\\"LocatorSize\\\":\\n scs_globals.locator_size = float(prop[1])\\n elif prop[0] == \\\"LocatorEmptySize\\\":\\n scs_globals.locator_empty_size = float(prop[1])\\n elif prop[0] == \\\"DisplayConnections\\\":\\n scs_globals.display_connections = prop[1]\\n elif prop[0] == \\\"CurveSegments\\\":\\n scs_globals.curve_segments = prop[1]\\n elif prop[0] == \\\"OptimizedConnsDrawing\\\":\\n scs_globals.optimized_connections_drawing = prop[1]\\n elif prop[0] == \\\"DisplayTextInfo\\\":\\n scs_globals.display_info = prop[1]\\n else:\\n lprint('W Unrecognised item \\\"%s\\\" has been found in setting file! Skipping...', (str(prop[0]),))\\n elif section.type == \\\"GlobalColors\\\":\\n for prop in section.props:\\n if prop[0] in (\\\"\\\", \\\"#\\\"):\\n pass\\n elif prop[0] == \\\"PrefabLocatorsWire\\\":\\n scs_globals.locator_prefab_wire_color = prop[1]\\n elif prop[0] == \\\"ModelLocatorsWire\\\":\\n scs_globals.locator_model_wire_color = prop[1]\\n elif prop[0] == \\\"ColliderLocatorsWire\\\":\\n scs_globals.locator_coll_wire_color = prop[1]\\n elif prop[0] == \\\"ColliderLocatorsFace\\\":\\n scs_globals.locator_coll_face_color = prop[1]\\n elif prop[0] == \\\"NavigationCurveBase\\\":\\n scs_globals.np_connection_base_color = prop[1]\\n elif prop[0] == \\\"MapLineBase\\\":\\n scs_globals.mp_connection_base_color = prop[1]\\n elif prop[0] == \\\"TriggerLineBase\\\":\\n scs_globals.tp_connection_base_color = prop[1]\\n elif prop[0] == \\\"InfoText\\\":\\n scs_globals.info_text_color = prop[1]\\n elif prop[0] == \\\"BasePaint\\\":\\n scs_globals.base_paint_color = prop[1]\\n else:\\n lprint('W Unrecognised item \\\"%s\\\" has been found in setting file! Skipping...', (str(prop[0]),))\\n elif section.type == \\\"Header\\\":\\n for prop in section.props:\\n if prop[0] == \\\"FormatVersion\\\":\\n if prop[1] == 1:\\n settings_file_valid += 1\\n elif prop[0] == \\\"Type\\\":\\n if prop[1] == \\\"Configuration\\\":\\n settings_file_valid += 1\\n elif prop[0] == \\\"DumpLevel\\\":\\n dump_level = prop[1]\\n elif prop[0] == \\\"ConfigStoragePlace\\\":\\n scs_globals.config_storage_place = prop[1]\\n\\n # if settings are read directly from blend file,\\n # release update lock and don't search/apply any settings further\\n if prop[1] == \\\"BlendFile\\\":\\n settings_file_valid += 1\\n\\n # as dump level can be read already (it can be placed above config storage place property),\\n # reset local variable back to value that was saved with blend file\\n dump_level = scs_globals.dump_level\\n\\n break # to avoid further reading of header properties, so dump_level won't be overwritten unintentionally\\n\\n scs_globals.dump_level = dump_level\\n\\n # now as last apply all of the file paths\\n # NOTE: applying paths is crucial for libraries\\n # (they are reloaded/initiated in property update functions).\\n if bpy.app.background: # if blender runs without UI then apply libraries directly as async operator is UI depended\\n\\n scs_globals.scs_project_path = scs_project_path\\n scs_globals.shader_presets_filepath = shader_presets_filepath\\n scs_globals.trigger_actions_rel_path = trigger_actions_rel_path\\n scs_globals.sign_library_rel_path = sign_library_rel_path\\n scs_globals.tsem_library_rel_path = tsem_library_rel_path\\n scs_globals.traffic_rules_library_rel_path = traffic_rules_library_rel_path\\n scs_globals.hookup_library_rel_path = hookup_library_rel_path\\n scs_globals.matsubs_library_rel_path = matsubs_library_rel_path\\n scs_globals.sun_profiles_lib_path = sun_profiles_library_path\\n scs_globals.conv_hlpr_converters_path = conv_hlpr_converters_path\\n\\n else: # if blender is started normally use asynchronous operator to reload libraries\\n\\n bpy.ops.world.scs_paths_initialization('INVOKE_DEFAULT', paths_list=[\\n {\\\"name\\\": \\\"project base path\\\", \\\"attr\\\": \\\"scs_project_path\\\", \\\"path\\\": scs_project_path},\\n {\\\"name\\\": \\\"shader presets\\\", \\\"attr\\\": \\\"shader_presets_filepath\\\", \\\"path\\\": shader_presets_filepath},\\n {\\\"name\\\": \\\"trigger actions library\\\", \\\"attr\\\": \\\"trigger_actions_rel_path\\\", \\\"path\\\": trigger_actions_rel_path},\\n {\\\"name\\\": \\\"sign library\\\", \\\"attr\\\": \\\"sign_library_rel_path\\\", \\\"path\\\": sign_library_rel_path},\\n {\\\"name\\\": \\\"traffic semaphore library\\\", \\\"attr\\\": \\\"tsem_library_rel_path\\\", \\\"path\\\": tsem_library_rel_path},\\n {\\\"name\\\": \\\"traffic rules library\\\", \\\"attr\\\": \\\"traffic_rules_library_rel_path\\\", \\\"path\\\": traffic_rules_library_rel_path},\\n {\\\"name\\\": \\\"hookups library\\\", \\\"attr\\\": \\\"hookup_library_rel_path\\\", \\\"path\\\": hookup_library_rel_path},\\n {\\\"name\\\": \\\"material substance library\\\", \\\"attr\\\": \\\"matsubs_library_rel_path\\\", \\\"path\\\": matsubs_library_rel_path},\\n {\\\"name\\\": \\\"sun profiles library\\\", \\\"attr\\\": \\\"sun_profiles_lib_path\\\", \\\"path\\\": sun_profiles_library_path},\\n {\\\"name\\\": \\\"converters file path\\\", \\\"attr\\\": \\\"conv_hlpr_converters_path\\\", \\\"path\\\": conv_hlpr_converters_path},\\n ])\\n\\n # release lock as properties are applied\\n release_config_lock(use_paths_init_callback=not bpy.app.background)\\n\\n return True\",\n \"def set_global_definitions(self):\\n # TODO: Investigate how this could be combined with the creation of\\n # self.configfiles in reffile_setup()\\n\\n self.global_subarray_definitions = {}\\n self.global_readout_patterns = {}\\n self.global_subarray_definition_files = {}\\n self.global_readout_pattern_files = {}\\n\\n self.global_crosstalk_files = {}\\n self.global_filtpupilcombo_files = {}\\n self.global_filter_position_files = {}\\n self.global_flux_cal_files = {}\\n self.global_psf_wing_threshold_file = {}\\n self.global_psfpath = {}\\n # self.global_filter_throughput_files = {} ?\\n\\n for instrument in 'niriss fgs nircam miri nirspec'.split():\\n if instrument.lower() == 'niriss':\\n readout_pattern_file = 'niriss_readout_pattern.txt'\\n subarray_def_file = 'niriss_subarrays.list'\\n crosstalk_file = 'niriss_xtalk_zeros.txt'\\n filtpupilcombo_file = 'niriss_dual_wheel_list.txt'\\n filter_position_file = 'niriss_filter_and_pupil_wheel_positions.txt'\\n flux_cal_file = 'niriss_zeropoints.list'\\n psf_wing_threshold_file = 'niriss_psf_wing_rate_thresholds.txt'\\n psfpath = os.path.join(self.datadir, 'niriss/gridded_psf_library')\\n elif instrument.lower() == 'fgs':\\n readout_pattern_file = 'guider_readout_pattern.txt'\\n subarray_def_file = 'guider_subarrays.list'\\n crosstalk_file = 'guider_xtalk_zeros.txt'\\n filtpupilcombo_file = 'guider_filter_dummy.list'\\n filter_position_file = 'dummy.txt'\\n flux_cal_file = 'guider_zeropoints.list'\\n psf_wing_threshold_file = 'fgs_psf_wing_rate_thresholds.txt'\\n psfpath = os.path.join(self.datadir, 'fgs/gridded_psf_library')\\n elif instrument.lower() == 'nircam':\\n readout_pattern_file = 'nircam_read_pattern_definitions.list'\\n subarray_def_file = 'NIRCam_subarray_definitions.list'\\n crosstalk_file = 'xtalk20150303g0.errorcut.txt'\\n filtpupilcombo_file = 'nircam_filter_pupil_pairings.list'\\n filter_position_file = 'nircam_filter_and_pupil_wheel_positions.txt'\\n flux_cal_file = 'NIRCam_zeropoints.list'\\n psf_wing_threshold_file = 'nircam_psf_wing_rate_thresholds.txt'\\n psfpath = os.path.join(self.datadir, 'nircam/gridded_psf_library')\\n else:\\n readout_pattern_file = 'N/A'\\n subarray_def_file = 'N/A'\\n crosstalk_file = 'N/A'\\n filtpupilcombo_file = 'N/A'\\n filter_position_file = 'N/A'\\n flux_cal_file = 'N/A'\\n psf_wing_threshold_file = 'N/A'\\n psfpath = 'N/A'\\n if instrument in 'niriss fgs nircam'.split():\\n self.global_subarray_definitions[instrument] = self.get_subarray_defs(filename=os.path.join(self.modpath, 'config', subarray_def_file))\\n self.global_readout_patterns[instrument] = self.get_readpattern_defs(filename=os.path.join(self.modpath, 'config', readout_pattern_file))\\n self.global_subarray_definition_files[instrument] = os.path.join(self.modpath, 'config', subarray_def_file)\\n self.global_readout_pattern_files[instrument] = os.path.join(self.modpath, 'config', readout_pattern_file)\\n self.global_crosstalk_files[instrument] = os.path.join(self.modpath, 'config', crosstalk_file)\\n self.global_filtpupilcombo_files[instrument] = os.path.join(self.modpath, 'config', filtpupilcombo_file)\\n self.global_filter_position_files[instrument] = os.path.join(self.modpath, 'config', filter_position_file)\\n self.global_flux_cal_files[instrument] = os.path.join(self.modpath, 'config', flux_cal_file)\\n self.global_psf_wing_threshold_file[instrument] = os.path.join(self.modpath, 'config', psf_wing_threshold_file)\\n self.global_psfpath[instrument] = psfpath\",\n \"def test_filters_with_extra_extraction(self) -> None:\\n\\n # pylint: disable=too-many-locals\\n\\n import hammer_config\\n\\n tech_dir, tech_dir_base = HammerToolTestHelpers.create_tech_dir(\\\"dummy28\\\")\\n tech_json_filename = os.path.join(tech_dir, \\\"dummy28.tech.json\\\")\\n\\n def add_named_library(in_dict: Dict[str, Any]) -> Dict[str, Any]:\\n out_dict = deepdict(in_dict)\\n out_dict[\\\"libraries\\\"].append({\\n \\\"name\\\": \\\"abcdef\\\",\\n \\\"milkyway techfile\\\": \\\"test/abcdef.tf\\\"\\n })\\n return out_dict\\n\\n HammerToolTestHelpers.write_tech_json(tech_json_filename, add_named_library)\\n sys.path.append(tech_dir_base)\\n tech = self.get_tech(hammer_tech.HammerTechnology.load_from_dir(\\\"dummy28\\\", tech_dir))\\n tech.cache_dir = tech_dir\\n\\n def filter_func(lib: hammer_tech.Library) -> bool:\\n return lib.milkyway_techfile is not None\\n\\n def paths_func(lib: hammer_tech.Library) -> List[str]:\\n assert lib.milkyway_techfile is not None\\n return [lib.milkyway_techfile]\\n\\n def extraction_func(lib: hammer_tech.Library, paths: List[str]) -> List[str]:\\n assert len(paths) == 1\\n if lib.name is None:\\n name = \\\"\\\"\\n else:\\n name = str(lib.name)\\n return [json.dumps({\\\"path\\\": paths[0], \\\"name\\\": name}, cls=HammerJSONEncoder, indent=4)]\\n\\n def sort_func(lib: hammer_tech.Library):\\n assert lib.milkyway_techfile is not None\\n return lib.milkyway_techfile\\n\\n test_filter = LibraryFilter.new(\\\"metatest\\\", \\\"Test filter that extracts metadata\\\",\\n is_file=True, filter_func=filter_func,\\n paths_func=paths_func,\\n extraction_func=extraction_func,\\n sort_func=sort_func)\\n\\n database = hammer_config.HammerDatabase()\\n tech.set_database(database)\\n raw = tech.process_library_filter(pre_filts=[], filt=test_filter,\\n must_exist=False,\\n output_func=hammer_tech.HammerTechnologyUtils.to_plain_item)\\n\\n # Disable false positive from pylint\\n outputs = list(map(lambda s: json.loads(s), raw)) # pylint: disable=unnecessary-lambda\\n self.assertEqual(outputs,\\n [\\n {\\\"path\\\": tech.prepend_dir_path(\\\"test/abcdef.tf\\\"), \\\"name\\\": \\\"abcdef\\\"},\\n {\\\"path\\\": tech.prepend_dir_path(\\\"test/coconut\\\"), \\\"name\\\": \\\"\\\"},\\n {\\\"path\\\": tech.prepend_dir_path(\\\"test/soy\\\"), \\\"name\\\": \\\"\\\"}\\n ])\\n\\n # Cleanup\\n shutil.rmtree(tech_dir_base)\",\n \"def __writeConfig(self):\\n page = None\\n\\n #TODO: get values of configurations here\\n particles = \\\"#f\\\" if not base.particleMgrEnabled else \\\"#t\\\"\\n volume = str(round(base.musicManager.getVolume(), 2))\\n mute = \\\"#f\\\" if base.AppHasAudioFocus else \\\"#t\\\"\\n #TODO: add any configuration variable name that you have added\\n customConfigVariables = [\\n \\\"\\\", \\\"particles-enabled\\\", \\\"audio-mute\\\", \\\"audio-volume\\\"]\\n if os.path.exists(prcFile):\\n # open the config file and change values according to current\\n # application settings\\n page = loadPrcFile(Filename.fromOsSpecific(prcFile))\\n removeDecls = []\\n for dec in range(page.getNumDeclarations()):\\n # Check if our variables are given.\\n # NOTE: This check has to be done to not loose our base or other\\n # manual config changes by the user\\n if page.getVariableName(dec) in customConfigVariables:\\n decl = page.modifyDeclaration(dec)\\n removeDecls.append(decl)\\n for dec in removeDecls:\\n page.deleteDeclaration(dec)\\n # NOTE: particles-enabled and audio-mute are custom variables and\\n # have to be loaded by hand at startup\\n # Particles\\n page.makeDeclaration(\\\"particles-enabled\\\", particles)\\n # audio\\n page.makeDeclaration(\\\"audio-volume\\\", volume)\\n page.makeDeclaration(\\\"audio-mute\\\", mute)\\n else:\\n # Create a config file and set default values\\n cpMgr = ConfigPageManager.getGlobalPtr()\\n page = cpMgr.makeExplicitPage(\\\"%s Pandaconfig\\\"%appName)\\n # set OpenGL to be the default\\n page.makeDeclaration(\\\"load-display\\\", \\\"pandagl\\\")\\n # get the displays width and height\\n w = self.pipe.getDisplayWidth()\\n h = self.pipe.getDisplayHeight()\\n # set the window size in the config file\\n page.makeDeclaration(\\\"win-size\\\", \\\"%d %d\\\"%(w, h))\\n # set the default to fullscreen in the config file\\n page.makeDeclaration(\\\"fullscreen\\\", \\\"1\\\")\\n # particles\\n page.makeDeclaration(\\\"particles-enabled\\\", \\\"#t\\\")\\n # audio\\n page.makeDeclaration(\\\"audio-volume\\\", volume)\\n page.makeDeclaration(\\\"audio-mute\\\", \\\"#f\\\")\\n # create a stream to the specified config file\\n configfile = OFileStream(prcFile)\\n # and now write it out\\n page.write(configfile)\\n # close the stream\\n configfile.close()\",\n \"def _initConfig(self):\\n from tg import config as tg_config\\n\\n # Set config defaults\\n config = DEFAULT_CONFIG.copy()\\n temp_verbose = config[\\\"verbose\\\"]\\n\\n # Configuration file overrides defaults\\n default_config_file = os.path.abspath(DEFAULT_CONFIG_FILE)\\n config_file = tg_config.get('wsgidav.config_path', default_config_file)\\n fileConf = self._readConfigFile(config_file, temp_verbose)\\n config.update(fileConf)\\n\\n if not useLxml and config[\\\"verbose\\\"] >= 1:\\n print(\\n \\\"WARNING: Could not import lxml: using xml instead (slower). Consider installing lxml from http://codespeak.net/lxml/.\\\")\\n from wsgidav.dir_browser import WsgiDavDirBrowser\\n from tracim.lib.webdav.tracim_http_authenticator import TracimHTTPAuthenticator\\n from wsgidav.error_printer import ErrorPrinter\\n from tracim.lib.webdav.utils import TracimWsgiDavDebugFilter\\n\\n config['middleware_stack'] = [\\n WsgiDavDirBrowser,\\n TracimHTTPAuthenticator,\\n ErrorPrinter,\\n TracimWsgiDavDebugFilter,\\n ]\\n\\n config['provider_mapping'] = {\\n config['root_path']: Provider(\\n # TODO: Test to Re enabme archived and deleted\\n show_archived=False, # config['show_archived'],\\n show_deleted=False, # config['show_deleted'],\\n show_history=False, # config['show_history'],\\n manage_locks=config['manager_locks']\\n )\\n }\\n\\n config['domaincontroller'] = TracimDomainController(presetdomain=None, presetserver=None)\\n\\n return config\",\n \"def main(parfile,verbose):\\n level = args.verbose.lower()\\n levels = { \\\"debug\\\": logging.DEBUG, \\\"info\\\": logging.INFO,\\n \\\"warn\\\": logging.WARNING,\\n \\\"warning\\\": logging.WARNING, \\\"error\\\": logging.ERROR }\\n if not level in levels:\\n logger.error ( \\\"Unknown log level ``%s'' supplied!\\\" % level )\\n sys.exit()\\n logger.setLevel(level = levels[level])\\n\\n parser = ConfigParserExt()\\n ret = parser.read(parfile)\\n if ret == []:\\n logger.error( \\\"No such file or directory: '%s'\\\" % parfile)\\n sys.exit()\\n\\n if not parser.has_option('options', 'input'):\\n logger.error(\\\"An input file or folder must be defined.\\\")\\n sys.exit()\\n else:\\n inputF = parser.get('options','input')\\n if os.path.isfile(inputF):\\n inputFiles = [os.path.abspath(inputF)]\\n elif \\\"*\\\" in inputF:\\n inputFiles = [os.path.abspath(f) for f in glob.glob(inputF)]\\n elif os.path.isdir(inputF):\\n inputFiles = [os.path.abspath(os.path.join(inputF,f))\\n for f in os.listdir(inputF)\\n if os.path.isfile(os.path.join(inputF, f))]\\n else:\\n logger.error(\\\"Input format %s not accepted\\\" %inputF)\\n sys.exit()\\n\\n parserList = []\\n for f in inputFiles:\\n newParser = ConfigParserExt()\\n newParser.read_dict(parser.toDict(raw=True))\\n newParser.set(\\\"CheckMateParameters\\\",\\\"SLHAFile\\\",f)\\n newParser.set(\\\"CheckMateParameters\\\",\\\"Name\\\",\\n os.path.splitext(os.path.basename(f))[0])\\n newParser.set(\\\"CheckMateParameters\\\",\\\"OutputDirectory\\\",\\n os.path.abspath(parser.get(\\\"CheckMateParameters\\\",\\\"OutputDirectory\\\")))\\n #Get tags of processes:\\n processTags = [tag for tag in newParser.sections()\\n if (tag.lower() != 'options' and tag.lower() != 'checkmateparameters')]\\n\\n #Get xsec dictionary:\\n useSLHA = False\\n unit = 'PB'\\n xsecDict = {}\\n if newParser.has_option(\\\"options\\\",\\\"xsecUnit\\\"):\\n unit = newParser.get(\\\"options\\\",\\\"xsecUnit\\\")\\n if newParser.has_option(\\\"options\\\",\\\"useSLHAxsecs\\\"):\\n useSLHA = newParser.get(\\\"options\\\",\\\"useSLHAxsecs\\\")\\n if not isinstance(useSLHA,dict):\\n logger.error(\\\"useSLHAxsecs should be defined as dictionary with a key for each CheckMate process.\\\")\\n sys.exit()\\n\\n xsecsAll = pyslha.readSLHAFile(f).xsections\\n for pTag,xsecTuple in useSLHA.items():\\n if not xsecTuple in xsecsAll: continue\\n xsecs = xsecsAll[xsecTuple].xsecs\\n xsecs = sorted(xsecs, key = lambda xsec: xsec.qcd_order,\\n reverse=True)\\n xsecDict[pTag] = xsecs[0]\\n\\n for pTag in processTags:\\n pName = newParser.get(pTag,\\\"Name\\\")\\n newParser.set(pTag,\\\"MGparam\\\",f)\\n if useSLHA:\\n if pTag in xsecDict:\\n newParser.set(pTag,\\\"XSect\\\", \\\"%1.5g %s\\\" %(xsecDict[pTag].value,unit))\\n if pName in xsecDict:\\n newParser.set(pTag,\\\"XSect\\\", \\\"%1.5g %s\\\" %(xsecDict[pName].value,unit))\\n\\n parserList.append(newParser)\\n\\n ncpus = int(parser.get(\\\"options\\\",\\\"ncpu\\\"))\\n if ncpus < 0:\\n ncpus = multiprocessing.cpu_count()\\n ncpus = min(ncpus,len(parserList))\\n pool = multiprocessing.Pool(processes=ncpus)\\n children = []\\n #Loop over parsers and submit jobs\\n logger.info(\\\"Submitting %i jobs over %i cores\\\" %(len(parserList),ncpus))\\n for newParser in parserList:\\n logger.debug(\\\"Submitting job for file %s\\\"\\n %(newParser.get(\\\"CheckMateParameters\\\",\\\"SLHAFile\\\")))\\n parserDict = newParser.toDict(raw=False) #Must convert to dictionary for pickling\\n p = pool.apply_async(RunCheckMate, args=(parserDict,))\\n children.append(p)\\n time.sleep(10)\\n\\n\\n #Wait for jobs to finish:\\n output = [p.get() for p in children]\\n for out in output:\\n print(out)\",\n \"def configuration_presets(configuration):\\n\\n # pylint: disable=too-many-branches\\n # pylint: disable=too-many-statements\\n\\n # Save the #defines\\n define_list = []\\n\\n # If not None, add in _DEBUG or NDEBUG\\n if configuration.debug is not None:\\n define_list.append(\\\"_DEBUG\\\" if configuration.debug else \\\"NDEBUG\\\")\\n\\n # Init the list of libraries to load\\n libraries_list = []\\n\\n # Sanity check for missing platform\\n platform = configuration.platform\\n if platform is not None:\\n\\n ide = configuration.project.ide\\n\\n # Force a test for the WATCOM environment variable\\n # for Watcom for Windows or DOS\\n if ide is IDETypes.watcom:\\n if platform.is_windows() or platform.is_msdos():\\n configuration.env_variable_list = [\\\"WATCOM\\\"]\\n\\n # Windows specific defines\\n if platform.is_windows():\\n\\n if ide.is_codewarrior():\\n configuration.library_folders_list = [\\n \\\"$(CodeWarrior)/MSL\\\", \\\"$(CodeWarrior)/Win32-x86 Support\\\"]\\n if configuration.debug:\\n libraries_list.append(\\\"MSL_All_x86_D.lib\\\")\\n else:\\n libraries_list.append(\\\"MSL_All_x86.lib\\\")\\n\\n libraries_list.extend(\\n [\\\"Kernel32.lib\\\", \\\"Gdi32.lib\\\", \\\"Shell32.lib\\\", \\\"Ole32.lib\\\",\\n \\\"User32.lib\\\", \\\"Advapi32.lib\\\", \\\"version.lib\\\", \\\"Ws2_32.lib\\\",\\n \\\"Comctl32.lib\\\", \\\"WinMM.lib\\\"])\\n\\n define_list.extend([\\\"_WINDOWS\\\", \\\"WIN32_LEAN_AND_MEAN\\\"])\\n if platform in (PlatformTypes.win64,\\n PlatformTypes.winarm64, PlatformTypes.winitanium):\\n define_list.append(\\\"WIN64\\\")\\n else:\\n define_list.append(\\\"WIN32\\\")\\n\\n # Command line tools need this define\\n if configuration.project_type is ProjectTypes.tool:\\n define_list.append(\\\"_CONSOLE\\\")\\n\\n # MSDos with DOS4GW extender\\n if platform is PlatformTypes.msdos4gw:\\n define_list.append(\\\"__DOS4G__\\\")\\n\\n # MSDos with X32 extender\\n if platform is PlatformTypes.msdosx32:\\n define_list.append(\\\"__X32__\\\")\\n\\n # Playstation 4\\n if platform is PlatformTypes.ps4:\\n define_list.append(\\\"__ORBIS2__\\\")\\n\\n # Include default libraries\\n libraries_list.extend((\\n \\\"SceSysmodule_stub_weak\\\",\\n \\\"ScePosix_stub_weak\\\",\\n \\\"SceVideoOut_stub_weak\\\",\\n \\\"ScePad_stub_weak\\\",\\n \\\"SceVideodec2_stub_weak\\\",\\n \\\"SceAudiodec_stub_weak\\\",\\n \\\"SceAudioOut_stub_weak\\\",\\n \\\"SceGnmDriver_stub_weak\\\",\\n \\\"SceGnm\\\",\\n \\\"SceGnmx\\\",\\n \\\"SceGpuAddress\\\"))\\n\\n # Playstation 5 (Not needed)\\n # if platform is PlatformTypes.ps5:\\n # define_list.append(\\\"__PROSPERO__\\\")\\n\\n # Playstation Vita\\n if platform is PlatformTypes.vita:\\n define_list.append(\\\"SN_TARGET_PSP2\\\")\\n\\n # Google Stadia\\n if platform is PlatformTypes.stadia:\\n define_list.append(\\\"_GNU_SOURCE\\\")\\n define_list.append(\\\"VK_USE_PLATFORM_GGP\\\")\\n\\n # Android targets\\n if platform.is_android():\\n define_list.append(\\\"DISABLE_IMPORTGL\\\")\\n libraries_list.extend([\\\"android\\\", \\\"EGL\\\", \\\"GLESv1_CM\\\"])\\n\\n # Xbox 360\\n if platform is PlatformTypes.xbox360:\\n define_list.extend([\\\"_XBOX\\\", \\\"XBOX\\\"])\\n libraries_list.extend([\\\"xbdm.lib\\\", \\\"xboxkrnl.lib\\\"])\\n if configuration.get_chained_value(\\\"profile\\\"):\\n libraries_list.extend(\\n [\\\"d3d9i.lib\\\", \\\"d3dx9i.lib\\\", \\\"xgraphics.lib\\\", \\\"xapilibi.lib\\\",\\n \\\"xaudio2.lib\\\", \\\"x3daudioi.lib\\\", \\\"xmcorei.lib\\\"])\\n elif configuration.debug:\\n libraries_list.extend(\\n [\\\"d3d9d.lib\\\", \\\"d3dx9d.lib\\\", \\\"xgraphicsd.lib\\\",\\n \\\"xapilibd.lib\\\", \\\"xaudiod2.lib\\\", \\\"x3daudiod.lib\\\",\\n \\\"xmcored.lib\\\"])\\n else:\\n libraries_list.extend(\\n [\\\"d3d9ltcg.lib\\\", \\\"d3dx9.lib\\\", \\\"xgraphics.lib\\\",\\n \\\"xapilib.lib\\\", \\\"xaudio2.lib\\\", \\\"x3daudioltcg.lib\\\",\\n \\\"xmcoreltcg.lib\\\"])\\n\\n # Xbox ONE\\n if platform is PlatformTypes.xboxone:\\n libraries_list.extend(\\n [\\\"pixEvt.lib\\\", \\\"d3d11_x.lib\\\", \\\"combase.lib\\\", \\\"kernelx.lib\\\",\\n \\\"uuid.lib\\\", \\\"%(XboxExtensionsDependencies)\\\"])\\n\\n # Nintendo DSI specific defines\\n if platform is PlatformTypes.dsi:\\n define_list.extend([\\n \\\"NN_BUILD_DEBUG\\\",\\n \\\"NN_COMPILER_RVCT\\\",\\n \\\"NN_COMPILER_RVCT_VERSION_MAJOR=$(CTRSDK_RVCT_VER_MAJOR)\\\",\\n \\\"NN_PROCESSOR_ARM\\\",\\n \\\"NN_PROCESSOR_ARM11MPCORE\\\",\\n \\\"NN_PROCESSOR_ARM_V6\\\",\\n \\\"NN_PROCESSOR_ARM_VFP_V2\\\",\\n \\\"NN_HARDWARE_CTR\\\",\\n \\\"NN_PLATFORM_CTR\\\",\\n \\\"NN_HARDWARE_CTR_TS\\\",\\n \\\"NN_SYSTEM_PROCESS\\\",\\n \\\"NN_SWITCH_ENABLE_HOST_IO=1\\\",\\n \\\"NN_BUILD_VERBOSE\\\",\\n \\\"NN_BUILD_NOOPT\\\",\\n \\\"NN_DEBUGGER_KMC_PARTNER\\\"])\\n\\n # Nintendo WiiU\\n if platform is PlatformTypes.wiiu:\\n configuration.include_folders_list.append(\\n \\\"$(CAFE_ROOT_DOS)\\\\\\\\system\\\\\\\\src\\\\\\\\tool\\\\\\\\gfx\\\\\\\\include\\\")\\n configuration.include_folders_list.append(\\n \\\"$(CAFE_ROOT_DOS)\\\\\\\\system\\\\\\\\include\\\")\\n\\n # Nintendo Switch\\n if platform.is_switch():\\n configuration.include_folders_list.append(\\n \\\"$(NINTENDO_SDK_ROOT)\\\\\\\\include\\\")\\n\\n if platform is PlatformTypes.switch32:\\n configuration.include_folders_list.append(\\n \\\"$(NINTENDO_SDK_ROOT)\\\\\\\\TargetSpecificInclude\\\\\\\\\\\"\\n \\\"NX-NXFP2-a32\\\")\\n else:\\n configuration.include_folders_list.append(\\n \\\"$(NINTENDO_SDK_ROOT)\\\\\\\\TargetSpecificInclude\\\\\\\\\\\"\\n \\\"NX-NXFP2-a64\\\")\\n\\n define_list.append(\\\"NN_NINTENDO_SDK\\\")\\n if configuration.debug:\\n define_list.append(\\\"NN_ENABLE_ASSERT\\\")\\n define_list.append(\\\"NN_ENABLE_ABORT_MESSAGE\\\")\\n if configuration.optimization:\\n define_list.append(\\\"NN_SDK_BUILD_DEVELOP\\\")\\n else:\\n define_list.append(\\\"NN_SDK_BUILD_DEBUG\\\")\\n else:\\n define_list.append(\\\"NN_SDK_BUILD_RELEASE\\\")\\n define_list.append(\\\"NN_DISABLE_ASSERT\\\")\\n define_list.append(\\\"NN_DISABLE_ABORT_MESSAGE\\\")\\n\\n # Linux platform\\n if platform is PlatformTypes.linux:\\n define_list.append(\\\"__LINUX__\\\")\\n\\n # Mac Carbon\\n if platform.is_macos_carbon():\\n define_list.append(\\\"TARGET_API_MAC_CARBON=1\\\")\\n\\n # macOS X platform frameworks\\n if platform.is_macosx():\\n if not configuration.project_type.is_library():\\n configuration.frameworks_list = [\\n \\\"AppKit.framework\\\", \\\"AudioToolbox.framework\\\",\\n \\\"AudioUnit.framework\\\", \\\"Carbon.framework\\\",\\n \\\"Cocoa.framework\\\", \\\"CoreAudio.framework\\\",\\n \\\"IOKit.framework\\\", \\\"OpenGL.framework\\\",\\n \\\"QuartzCore.framework\\\", \\\"SystemConfiguration.framework\\\"\\n ]\\n\\n # iOS platform frameworks\\n if platform.is_ios():\\n if not configuration.project_type.is_library():\\n configuration.frameworks_list = [\\n \\\"AVFoundation.framework\\\", \\\"CoreGraphics.framework\\\",\\n \\\"CoreLocation.framework\\\", \\\"Foundation.framework\\\",\\n \\\"QuartzCore.framework\\\", \\\"UIKit.framework\\\"\\n ]\\n\\n # Save the macros\\n configuration.define_list = define_list\\n\\n # Only link libraries for executables.\\n project_type = configuration.project_type\\n if project_type is not None:\\n if not project_type.is_library():\\n configuration.libraries_list = libraries_list\",\n \"def parse_config(self):\\n # TODO: parse config file\\n pass\",\n \"def load(cls, filenames, config_factory=Config):\\n return cls([config_factory(f, label=label) for label, f in filenames])\",\n \"def apply_config(self, config_path: str) -> None:\\n # pylint: disable=exec-used\\n try:\\n assert self._active_feature_set is None\\n type(self)._active_feature_set = self\\n\\n # Apply both src and dist spinoff configs.\\n exec_context: dict = {}\\n with open(config_path, encoding='utf-8') as infile:\\n config_contents = infile.read()\\n\\n # Use compile here so we can provide a nice file path for\\n # error tracebacks.\\n exec(\\n compile(config_contents, config_path, 'exec'),\\n exec_context,\\n exec_context,\\n )\\n\\n finally:\\n assert type(self)._active_feature_set is self\\n type(self)._active_feature_set = None\",\n \"def update_config(self):\\n if self.integration is None:\\n return\\n self.enabled = self.integration.has_option(self.get_config_name())\\n self.pedantic = self.integration.configuration.get_bool(\\n 'filter.mrproper')\",\n \"def __init__(self):\\n ConfigParser.RawConfigParser.OPTCRE = re.compile(r'(?P<option>[^=\\\\s][^=]*)\\\\s*(?P<vi>[=])\\\\s*(?P<value>.*)$')\\n self.CONFIG = ConfigParser.ConfigParser()\\n self.CONFIG.read(os.path.join(os.path.dirname(__file__)))\\n self.IPS = []\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7449922","0.62407774","0.61889404","0.59549785","0.59027463","0.58631474","0.5609206","0.5593095","0.55149376","0.55030483","0.5462658","0.5454153","0.5419757","0.5368659","0.53600055","0.5356726","0.5343718","0.5336285","0.5318649","0.5306495","0.5306188","0.5293002","0.52896225","0.5275666","0.5270552","0.5266128","0.5265937","0.52559286","0.52427423","0.5242432","0.5238375","0.5228893","0.52155405","0.5192928","0.5192612","0.5191933","0.51842463","0.51785225","0.51737416","0.51737416","0.51542556","0.51541513","0.51496434","0.51451063","0.5139216","0.5132209","0.5131527","0.51229954","0.51124865","0.51100475","0.5109368","0.5108647","0.5100003","0.50940347","0.50909567","0.5080678","0.50778174","0.5076927","0.5075671","0.5065307","0.5060205","0.50579435","0.50415754","0.5041407","0.5041407","0.5041018","0.5037997","0.5031113","0.50268066","0.50267446","0.50234365","0.50177383","0.50099707","0.50086534","0.5002938","0.49972412","0.4995691","0.4988702","0.49830037","0.49815032","0.49810994","0.4980911","0.49792954","0.49730614","0.49680585","0.49678773","0.49647027","0.49640793","0.4963771","0.495358","0.49526253","0.49500114","0.49488938","0.49460405","0.49440622","0.49429092","0.4938454","0.49356306","0.4929746","0.4928568","0.4928345"],"string":"[\n \"0.7449922\",\n \"0.62407774\",\n \"0.61889404\",\n \"0.59549785\",\n \"0.59027463\",\n \"0.58631474\",\n \"0.5609206\",\n \"0.5593095\",\n \"0.55149376\",\n \"0.55030483\",\n \"0.5462658\",\n \"0.5454153\",\n \"0.5419757\",\n \"0.5368659\",\n \"0.53600055\",\n \"0.5356726\",\n \"0.5343718\",\n \"0.5336285\",\n \"0.5318649\",\n \"0.5306495\",\n \"0.5306188\",\n \"0.5293002\",\n \"0.52896225\",\n \"0.5275666\",\n \"0.5270552\",\n \"0.5266128\",\n \"0.5265937\",\n \"0.52559286\",\n \"0.52427423\",\n \"0.5242432\",\n \"0.5238375\",\n \"0.5228893\",\n \"0.52155405\",\n \"0.5192928\",\n \"0.5192612\",\n \"0.5191933\",\n \"0.51842463\",\n \"0.51785225\",\n \"0.51737416\",\n \"0.51737416\",\n \"0.51542556\",\n \"0.51541513\",\n \"0.51496434\",\n \"0.51451063\",\n \"0.5139216\",\n \"0.5132209\",\n \"0.5131527\",\n \"0.51229954\",\n \"0.51124865\",\n \"0.51100475\",\n \"0.5109368\",\n \"0.5108647\",\n \"0.5100003\",\n \"0.50940347\",\n \"0.50909567\",\n \"0.5080678\",\n \"0.50778174\",\n \"0.5076927\",\n \"0.5075671\",\n \"0.5065307\",\n \"0.5060205\",\n \"0.50579435\",\n \"0.50415754\",\n \"0.5041407\",\n \"0.5041407\",\n \"0.5041018\",\n \"0.5037997\",\n \"0.5031113\",\n \"0.50268066\",\n \"0.50267446\",\n \"0.50234365\",\n \"0.50177383\",\n \"0.50099707\",\n \"0.50086534\",\n \"0.5002938\",\n \"0.49972412\",\n \"0.4995691\",\n \"0.4988702\",\n \"0.49830037\",\n \"0.49815032\",\n \"0.49810994\",\n \"0.4980911\",\n \"0.49792954\",\n \"0.49730614\",\n \"0.49680585\",\n \"0.49678773\",\n \"0.49647027\",\n \"0.49640793\",\n \"0.4963771\",\n \"0.495358\",\n \"0.49526253\",\n \"0.49500114\",\n \"0.49488938\",\n \"0.49460405\",\n \"0.49440622\",\n \"0.49429092\",\n \"0.4938454\",\n \"0.49356306\",\n \"0.4929746\",\n \"0.4928568\",\n \"0.4928345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12875,"cells":{"query":{"kind":"string","value":"Creates the three final Libraries."},"document":{"kind":"string","value":"def createFinalLibraries(INTERMEDIATELIBRARIES, DICOLIBRARIES):\n\t#### Parse all the intermediate libraries files\n\tfor file in INTERMEDIATELIBRARIES:\n\t\tfileName = os.path.basename(file).split(\".fasta\")[0]\n\t\t#### Read and store the fasta sequences of the prelibraries\n\t\tsequences=readInput.readFasta(file)\n\t\t#### Save the three finals libraries\n\t\tsave.saveLibraries(sequences, DICOLIBRARIES)"},"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 createIntermediateLibraries(LISTPRELIBRARIES, DICOLIBRARIES, CONFIG, DICOFINALCLASSIF):\n\t#### Parse all the intermediate libraries files\n\tfor preLibrary in LISTPRELIBRARIES:\n\t\t#### Retrieve the final classification name of the ET from the file name\n\t\tfinalClassification = os.path.basename(preLibrary).split(\".fasta\")[0]\n\t\t#### Read and store the fasta sequences of the prelibraries\n\t\tsequences=readInput.readFasta(preLibrary)\n\t\t#### Parse all the sequences\n\t\tfor id in sequences:\n\t\t\t#### Check the finalClassification of the sequences is in the ID\n\t\t\tif finalClassification.lower() in id.lower():\n\t\t\t\tDICOFINALCLASSIF[id]=finalClassification\n\t\t\t\tapplyFiltersForIntermediate(id, sequences, finalClassification, CONFIG, DICOLIBRARIES)","def makeLibrary(self):\n #------------------------------------------ Instance for the output file\n outputFile = open(\"%s/%s\" % (self.sceneryPath,self.libTxtFileName),\"w\")\n #------------------------------------------------------ write the header\n for line in self.header:\n outputFile.write(\"%s\\n\" % (line))\n #------------------------------------------------- Loop over all folders\n packageContent = os.walk(self.sceneryPath)\n for folder in packageContent:\n for fileName in folder[2]:\n fileType = fileName.split(\".\")[-1]\n if fileType in self.objectTypes:\n realPath = folder[0][len(self.sceneryPath)+1:].replace(\"\\\\\",\"/\")\n filePath = \"%s/%s\" % (realPath,fileName)\n print filePath\n outputFile.write(\"EXPORT %s%s %s%s\\n\" % (self.libPrefix,filePath,self.realPathPrefix,filePath))\n outputFile.close()","def _shared_library_in_2steps(env):\r\n\r\n if not config.shared_library_1st in env['BUILDERS']:\r\n # The 1st builder\r\n shlinkcom_name = config.shared_library_1st + \"COM\"\r\n env[shlinkcom_name] = \"${TEMPFILE('$AR /DEF $ARFLAGS /OUT:$TARGET $SOURCES')}\"\r\n ar_action = SCons.Action.Action(\"$\" + shlinkcom_name, \"building '$TARGET' from '$SOURCE'\")\r\n emitter_name = config.shared_library_1st + \"EMITTER\"\r\n env[emitter_name] = [__lib_export_emitter]\r\n env[\"BUILDERS\"][config.shared_library_1st] = SCons.Builder.Builder(\r\n action=ar_action,\r\n emitter=\"$\" + emitter_name,\r\n prefix=\"$LIBPREFIX\",\r\n suffix=\"$LIBSUFFIX\",\r\n src_suffix=\"$SHOBJSUFFIX\",\r\n src_builder=\"SharedObject\")\r\n\r\n if not config.shared_library_2nd in env['BUILDERS']:\r\n # The 2nd builder\r\n emitter_name = config.shared_library_2nd + \"EMITTER\"\r\n env[emitter_name] = [__win32_lib_emitter]\r\n env[\"BUILDERS\"][config.shared_library_2nd] = SCons.Builder.Builder(\r\n action=[SCons.Defaults.SharedCheck,\r\n SCons.Action.Action(\"$SHLINKCOM\", \"building '$TARGET' from '$SOURCE'\")],\r\n emitter=\"$\" + emitter_name,\r\n prefix=\"$SHLIBPREFIX\",\r\n suffix=\"$SHLIBSUFFIX\",\r\n target_scanner=SCons.Scanner.Prog.ProgramScanner(),\r\n src_suffix=\"$SHOBJSUFFIX\",\r\n src_builder=\"SharedObject\")","def library_dirs(self):","def linking_library_dirs(self):","def create_libs(desc: dict, pins: list, output_dir: str, verbose: bool = False):\n db = desc.copy()\n db[\"block_name\"] = desc[\"name_of_the_cell\"]\n db[\"area\"] = db.pop(\"block_area_(um2)\")\n db[\"pins\"] = pins\n db[\"types\"] = [pin for pin in pins if pin.width > 1]\n lib_paths = []\n for corner, condition in desc.get(\"corners\", {}).items():\n db[\"library\"] = \"%s_%s_%sV_%sC\" % (\n desc.get(\"name_of_the_cell\"),\n corner,\n (\"%.2f\" % condition.get(\"voltage\")).replace('.', '_'),\n str(condition.get(\"temperature\")).replace('-', 'm')\n )\n db[\"corner_name\"] = corner\n db[\"corner\"] = condition\n if verbose:\n print(db)\n # create directory if does not exist\n os.makedirs(output_dir, exist_ok=True)\n # generate lib file\n template_file = os.path.join(os.path.dirname(__file__), \"./template_ana.lib.mako\")\n _tmp = Template(filename=template_file)\n lib_path = os.path.join(output_dir, \"%s.lib\" % db[\"library\"])\n with open(lib_path, \"w+\") as fp:\n fp.write(_tmp.render_unicode(**db))\n lib_paths.append(lib_path)\n return lib_paths","def genLibData(self):\n import mush\n tsMain = string.Template(mush.libGenMain)\n tsIfAltId = string.Template(mush.libGenIfAltId)\n #--Data Records\n for id in ('lib_action','lib_actionCount'):\n glob = self.getRecord('GLOB',id,Glob)\n (glob.type, glob.value) = ('s',0)\n glob.setChanged()\n setAllCode = 'begin lib_setAllGS\\n'\n setNoneCode = 'begin lib_setNoneGS\\n'\n for libId in self.libList:\n (srcId,altId) = self.libMap[libId]\n srcBook = self.srcBooks.get(srcId)[0]\n if not srcBook:\n print '%s: Missing source: %s' % (libId,srcId)\n continue\n #--Global\n glob = self.getRecord('GLOB',libId+'G',Glob)\n (glob.type, glob.value) = ('s',0)\n glob.setChanged()\n #--Script\n scriptId = libId+'LS'\n script = self.getRecord('SCPT',scriptId,Scpt)\n scriptCode = tsMain.substitute(\n libId=libId, srcId=srcId, ifAltId=(\n (altId and tsIfAltId.substitute(libId=libId,altId=altId)) or ''))\n script.setCode(scriptCode)\n script.setChanged()\n #--Book\n srcBook.load(unpack=True)\n book = self.getRecord('BOOK',libId,Book)\n book.model = srcBook.model\n book.title = srcBook.title\n book.icon = srcBook.icon\n book.text = srcBook.text\n book.script = scriptId\n book.setChanged()\n #--Set Scripts\n setAllCode += 'set %sG to 1\\n' % (libId,)\n setNoneCode += 'set %sG to 0\\n' % (libId,)\n #--Set scripts\n for id,code in (('lib_setAllGS',setAllCode),('lib_setNoneGS',setNoneCode)):\n code += ';--Done\\nstopScript %s\\nend\\n' % (id,)\n script = self.getRecord('SCPT',id,Scpt)\n script.setCode(code)\n script.setChanged()","def initialize_libraries(experiment, ln):\n # Move into the folder to do the intial calculations in\n folder = \"initial_library\" + str(ln)\n os.chdir(folder) \n # Create a time stamp for beginning the calculations\n experiment[\"Summary\"] = \"Library \" + str(ln) + \" Initialization\\n\"\n experiment[\"Summary\"] += \"Started\" + SHARING.time_stamp()\n # Find the proper number of coordinates to consider\n N = len(experiment[\"Movements\"][ln])/2\n # Go through each antigen\n for mol in experiment[0]:\n # Apply the proper rotation\n for cn in range(N):\n # Create a generic vector of zeros of the appropriate length\n vector = [0.0] * N\n # Place a value of 1.0 in the correct location in the vector\n vector[cn] = 1.0\n # Find the angle to rotate the antigens by\n angle = experiment[\"Movements\"][ln][N+cn]\n # Rotate each of the antigens by the appropriate angle\n rmatrix = MOLECULES.calculate_rmatrix(angle, vector)\n MOLECULES.rotate(mol, rmatrix)\n # Translate each antigen by the appropriate amount\n MOLECULES.move(mol, experiment[\"Movements\"][ln][:N], '+')\n # Update the reference folder with these updated coordinates\n SHARING.output_Current(experiment, \"./Current/\") \n # Load the canonical structures\n canonicals = IPRO_FUNCTIONS.load_canonicals(experiment)\n cdrs = list(canonicals.keys())\n cdrs.sort()\n # Load the clashes\n clashes = IPRO_FUNCTIONS.load_clashes(experiment, cdrs) \n # Load the C++ scores\n raw_scores = IPRO_FUNCTIONS.load_scores(experiment[\"Folder\"])\n # Look for alternate solutions using integer cuts\n goOn = True\n # Store the solutions in a list\n solutions = [experiment[\"Scores\"][ln-1]]\n # Keep searching for alternate solutions until the quality of the result is\n # worse\n while goOn:\n # Resolve the MILP using integer cuts\n if useCPLEX:\n #solution = CPLEX.optcdr_canonicals(canonicals, clashes, \\\n # raw_scores[ln], solutions)\n pass\n else:\n solution = GAMS.optcdr_canonicals(canonicals, clashes, \\\n raw_scores[ln], solutions)\n # If the solution found has an equal objective value to the first, store\n # it and re-run the MILP\n if solution[\"Score\"] == experiment[\"Scores\"][ln-1][1][\"Score\"]:\n solutions.append([experiment[\"Scores\"][ln-1][0], solution])\n # Otherwise, break out of the loop and analyze the results\n else:\n goOn = False\n # Update the library based on the most members for the cluster\n best = 0\n # Skip this if there is only one solution after applying the integer cuts\n if len(solutions) > 1:\n # Load the clusters\n cdrs = list(canonicals.keys())\n cdrs.sort()\n clusters = load_clusters(experiment, cdrs)\n # Initialize the variables to store the solution with the most cluster\n # members\n best = None\n amount = 0\n # Go through the solutions\n for i, solution in enumerate(solutions):\n # Store the total number of members throughout the CDRs\n total = 0\n # Go through the CDRs\n for j, cdr in enumerate(cdrs):\n # Extract the number of members from the \"clusters\" dictionary \n members = clusters[cdr][solution[1][j+1]][\"Members\"]\n # 30 is the number where the permitted amino acids change from\n # \"of the same type\" to \"only those observed\" at each position\n if members > 30:\n members = 30\n # Add the number of members to the total for this solution\n total += members\n # If applicable, update the \"best\" solution found and its\n # corresponding total number of members\n if total > amount:\n best = i\n amount = total\n # Update the library based on the most structures\n experiment[\"Scores\"][ln-1] = solutions[best]\n # If the set of canonical structures has changed, update the referenced\n # values\n if best != 0:\n SHARING.output_scores(experiment, experiment[\"Folder\"] + \"Current/\", ln)\n # Copy the necessary files\n SHARING.copy_standard_files(experiment, solv = True) \n # Generate the antibody structures\n build_antibodies(experiment, canonicals, ln) \n # Go back to the home directory\n os.chdir(\"../\")\n # Try to create a new folder to handle the IPRO affinity maturation\n folder = \"library\" + str(ln)\n try:\n os.mkdir(folder)\n # If the folder already exists, delete it and make a new one. This is the\n # proper procedure since the library should only be there if the\n # initialization has already finished\n except OSError:\n os.system(\"rm -rf \" + folder)\n os.mkdir(folder)\n # Create a new Experiment class object to handle the IPRO affinity maturation\n make_IPRO_experiment(experiment, folder)\n # Delete the initialization folder\n os.system(\"rm -rf initial_\" + folder) \n # Update the summary file\n # Create a summary file\n experiment[\"Summary\"] += \"Ended\" + SHARING.time_stamp()\n name = SHARING.summary_name(SHARING.get_current())\n f = open(name, \"a\")\n f.write(experiment[\"Summary\"])\n f.close()","def build_assets():\n\n # templates\n template = open(os.path.join(BASE_PATH, 'AssetLibrary.as.template'), 'r').read()\n\n embed_templates = {\n 'image': \"[Embed(source='%(asset_path)s')] private var %(asset_class_name)s:Class;\\n\",\n 'mp3': \"[Embed(source='%(asset_path)s')] private var %(asset_class_name)s:Class;\\n\", \n 'xml': \"[Embed(source='%(asset_path)s', mimeType=\\\"application/octet-stream\\\")] private var %(asset_class_name)s:Class;\\n\"\n }\n \n library_element_template = \"'%(asset_id)s': %(asset_class_name)s\"\n\n # load+parse asset xml\n complete_asset_embed_code = \"\"\n complete_asset_data_code = \"\"\n asset_dom = minidom.parse(ASSET_XML_FILE)\n \n asset_nodes = list(asset_dom.getElementsByTagName('asset'))\n \n for asset_node in asset_nodes:\n asset_attrs = dict(asset_node.attributes.items())\n asset_embed_code = embed_templates[asset_attrs['type']] % {\n 'asset_class_name': asset_attrs['name'],\n 'asset_path': ASSET_BASE + asset_attrs['file']\n }\n\n complete_asset_embed_code += asset_embed_code\n \n asset_data_code = library_element_template % {\n 'asset_id': asset_attrs['name'],\n 'asset_class_name': asset_attrs['name']\n }\n\n complete_asset_data_code += asset_data_code\n\n if asset_nodes.index(asset_node) == len(asset_nodes) - 1:\n complete_asset_data_code += \"\\n\"\n else:\n complete_asset_data_code += \",\\n\"\n \n output = template % {\n 'asset_embeds': complete_asset_embed_code,\n 'asset_data': complete_asset_data_code\n }\n \n # render\n output_f = open(os.path.join(BASE_PATH, 'AssetLibrary.as'), 'w')\n output_f.write(output)","def test_project_with_dependencies(self):\n self.make_project()\n # 'test_library.zip' is not currently compiled for diorite.\n self.project.app_platforms = \"aplite,basalt,chalk\"\n self.project.save()\n tempdir = tempfile.mkdtemp()\n try:\n # Extract a premade library to a temporary directory\n ZipFile(LIBRARY_PATH).extractall(tempdir)\n lib_path = os.path.join(tempdir, 'libname')\n\n # Include the library in the code and package.json\n self.add_file(\"main.c\", DEPENDENCY_MAIN)\n self.project.set_dependencies({\n 'libname': lib_path\n })\n\n # Compile and check\n self.compile()\n self.check_compile_success(num_platforms=3)\n finally:\n shutil.rmtree(tempdir)","def make_productions3(self):\n self.make_productions2()\n for prod in self.make_productions_preterminals():\n self.productions.add(prod)","def save_libraries(self, a, lib):\n logging.debug(\"in save libraries\")\n self.libraries.append(lib)\n self.produce(\"library\", lib)","def _copy_bins():\n # STEP 1: If we're performing a build from a copied source tree,\n # copy the generated python files into the package\n\n _clean_bins()\n\n py_z3_build_dir = os.path.join(BUILD_DIR, 'python', 'z3')\n root_z3_dir = os.path.join(ROOT_DIR, 'z3')\n shutil.copy(os.path.join(py_z3_build_dir, 'z3core.py'), root_z3_dir)\n shutil.copy(os.path.join(py_z3_build_dir, 'z3consts.py'), root_z3_dir)\n\n # STEP 2: Copy the shared library, the executable and the headers\n\n os.mkdir(LIBS_DIR)\n os.mkdir(BINS_DIR)\n os.mkdir(HEADERS_DIR)\n shutil.copy(os.path.join(BUILD_DIR, LIBRARY_FILE), LIBS_DIR)\n shutil.copy(os.path.join(BUILD_DIR, EXECUTABLE_FILE), BINS_DIR)\n path1 = glob.glob(os.path.join(BUILD_DIR, \"msvcp*\"))\n path2 = glob.glob(os.path.join(BUILD_DIR, \"vcomp*\"))\n path3 = glob.glob(os.path.join(BUILD_DIR, \"vcrun*\"))\n for filepath in path1 + path2 + path3:\n shutil.copy(filepath, LIBS_DIR)\n\n for header_dir in HEADER_DIRS:\n for fname in os.listdir(header_dir):\n if not fname.endswith('.h'):\n continue\n shutil.copy(os.path.join(header_dir, fname), os.path.join(HEADERS_DIR, fname))\n\n # This hack lets z3 installed libs link on M1 macs; it is a hack, not a proper fix\n # @TODO: Linked issue: https://github.com/Z3Prover/z3/issues/5926\n major_minor = '.'.join(_z3_version().split('.')[:2])\n link_name = None\n if BUILD_PLATFORM in ('win32', 'cygwin', 'win'):\n pass # TODO: When windows VMs work on M1, fill this in\n elif BUILD_PLATFORM in ('darwin', 'osx'):\n split = LIBRARY_FILE.split('.')\n link_name = split[0] + '.' + major_minor + '.' + split[1]\n else:\n link_name = LIBRARY_FILE + '.' + major_minor\n if link_name:\n os.symlink(LIBRARY_FILE, os.path.join(LIBS_DIR, link_name), True)","def add_library(self):\n library = self.new_section('The Library')\n books = self.wiki('the-library')._soup(class_='boxbook')\n template = (\n '<div class=\"book-title\">{}</div>'\n '<div class=\"book-description\">{}</div>')\n for b in books:\n title = b.find(class_='booktitle').string\n description = b.find(class_='boxleft')('div')[0].text.strip()\n excerpts = [self.wiki.site + a['href']\n for a in b.find(class_='boxright')('a')]\n if title == 'The Journal of Aframos Longjourney':\n links = self.wiki(excerpts[1])._soup.select('#page-content a')\n links = [\n 'http://wanderers-library.wikidot.com/' +\n l['href'].split('/')[-1] for l in links]\n excerpts = [excerpts[0]] + links\n book = self.add_page(\n title, template.format(title, description), library)\n for url in excerpts:\n self.add_url(url, book)","def create_data_base():\n\n\tscript_files = []\n\tjson_files = []\n\t\n\t# get script files list\n\tfor file in os.listdir(\"learned_objects_scripts/\"):\n\t\tif file.endswith(\".script\"):\n\t\t\tscript_files.append(file)\n\n\t# get json files list\n\tfor file in os.listdir(\"object_models/\"):\n\t\tif file.endswith(\".json\"):\n\t\t\tjson_files.append(file)\n\t\n\t# create json file for new objects\n\tmodel_created = False\n\tfor file in script_files:\n\t\tif \"{}.json\".format(file[:-7]) not in json_files:\n\t\t\twith open(\"object_models/{}.json\".format(file[:-7]), 'w') as outfile:\n\t\t\t\tobj_model = object_script_to_model(\"learned_objects_scripts/\" + file)\n\t\t\t\tjson.dump(obj_model, outfile)\n\t\t\t\tmodel_created = True\n\t\t\t\tprint(\"model created for\", file)\n\tif not model_created:\n\t\tprint(\"data base is already up to date\")","def gather() -> None:\n # pylint: disable=too-many-locals\n\n # First off, clear out any existing output.\n existing_dirs = [\n os.path.join('src/external', d) for d in os.listdir('src/external')\n if d.startswith('python-') and d != 'python-notes.txt'\n ]\n existing_dirs += [\n os.path.join('assets/src', d) for d in os.listdir('assets/src')\n if d.startswith('pylib-')\n ]\n for existing_dir in existing_dirs:\n efrotools.run('rm -rf \"' + existing_dir + '\"')\n\n for buildtype in ['debug', 'release']:\n debug = buildtype == 'debug'\n bsuffix = '_debug' if buildtype == 'debug' else ''\n bsuffix2 = '-debug' if buildtype == 'debug' else ''\n\n libname = 'python' + PYTHON_VERSION_MAJOR + ('dm' if debug else 'm')\n\n bases = {\n 'mac':\n f'build/python_apple_mac{bsuffix}/build/macOS',\n 'ios':\n f'build/python_apple_ios{bsuffix}/build/iOS',\n 'tvos':\n f'build/python_apple_tvos{bsuffix}/build/tvOS',\n 'android_arm':\n f'build/python_android_arm{bsuffix}/build/sysroot',\n 'android_arm64':\n f'build/python_android_arm64{bsuffix}/build/sysroot',\n 'android_x86':\n f'build/python_android_x86{bsuffix}/build/sysroot',\n 'android_x86_64':\n f'build/python_android_x86_64{bsuffix}/build/sysroot'\n }\n\n # Note: only need pylib for the first in each group.\n builds: List[Dict[str, Any]] = [{\n 'name':\n 'macos',\n 'group':\n 'apple',\n 'headers':\n bases['mac'] + '/Support/Python/Headers',\n 'libs': [\n bases['mac'] + '/Support/Python/libPython.a',\n bases['mac'] + '/Support/OpenSSL/libOpenSSL.a',\n bases['mac'] + '/Support/XZ/libxz.a'\n ],\n 'pylib':\n (bases['mac'] + '/python/lib/python' + PYTHON_VERSION_MAJOR),\n }, {\n 'name':\n 'ios',\n 'group':\n 'apple',\n 'headers':\n bases['ios'] + '/Support/Python/Headers',\n 'libs': [\n bases['ios'] + '/Support/Python/libPython.a',\n bases['ios'] + '/Support/OpenSSL/libOpenSSL.a',\n bases['ios'] + '/Support/XZ/libxz.a'\n ],\n }, {\n 'name':\n 'tvos',\n 'group':\n 'apple',\n 'headers':\n bases['tvos'] + '/Support/Python/Headers',\n 'libs': [\n bases['tvos'] + '/Support/Python/libPython.a',\n bases['tvos'] + '/Support/OpenSSL/libOpenSSL.a',\n bases['tvos'] + '/Support/XZ/libxz.a'\n ],\n }, {\n 'name':\n 'android_arm',\n 'group':\n 'android',\n 'headers':\n bases['android_arm'] + f'/usr/include/{libname}',\n 'libs': [\n bases['android_arm'] + f'/usr/lib/lib{libname}.a',\n bases['android_arm'] + '/usr/lib/libssl.a',\n bases['android_arm'] + '/usr/lib/libcrypto.a',\n bases['android_arm'] + '/usr/lib/liblzma.a',\n bases['android_arm'] + '/usr/lib/libsqlite3.a'\n ],\n 'libinst':\n 'android_armeabi-v7a',\n 'pylib': (bases['android_arm'] + '/usr/lib/python' +\n PYTHON_VERSION_MAJOR),\n }, {\n 'name': 'android_arm64',\n 'group': 'android',\n 'headers': bases['android_arm64'] + f'/usr/include/{libname}',\n 'libs': [\n bases['android_arm64'] + f'/usr/lib/lib{libname}.a',\n bases['android_arm64'] + '/usr/lib/libssl.a',\n bases['android_arm64'] + '/usr/lib/libcrypto.a',\n bases['android_arm64'] + '/usr/lib/liblzma.a',\n bases['android_arm64'] + '/usr/lib/libsqlite3.a'\n ],\n 'libinst': 'android_arm64-v8a',\n }, {\n 'name': 'android_x86',\n 'group': 'android',\n 'headers': bases['android_x86'] + f'/usr/include/{libname}',\n 'libs': [\n bases['android_x86'] + f'/usr/lib/lib{libname}.a',\n bases['android_x86'] + '/usr/lib/libssl.a',\n bases['android_x86'] + '/usr/lib/libcrypto.a',\n bases['android_x86'] + '/usr/lib/liblzma.a',\n bases['android_x86'] + '/usr/lib/libsqlite3.a'\n ],\n 'libinst': 'android_x86',\n }, {\n 'name': 'android_x86_64',\n 'group': 'android',\n 'headers': bases['android_x86_64'] + f'/usr/include/{libname}',\n 'libs': [\n bases['android_x86_64'] + f'/usr/lib/lib{libname}.a',\n bases['android_x86_64'] + '/usr/lib/libssl.a',\n bases['android_x86_64'] + '/usr/lib/libcrypto.a',\n bases['android_x86_64'] + '/usr/lib/liblzma.a',\n bases['android_x86_64'] + '/usr/lib/libsqlite3.a'\n ],\n 'libinst': 'android_x86_64',\n }]\n\n for build in builds:\n\n grp = build['group']\n builddir = f'src/external/python-{grp}{bsuffix2}'\n header_dst = os.path.join(builddir, 'include')\n lib_dst = os.path.join(builddir, 'lib')\n assets_src_dst = f'assets/src/pylib-{grp}'\n\n # Do some setup only once per group.\n if not os.path.exists(builddir):\n efrotools.run('mkdir -p \"' + builddir + '\"')\n efrotools.run('mkdir -p \"' + lib_dst + '\"')\n\n # Only pull modules into game assets on release pass.\n if not debug:\n # Copy system modules into the src assets\n # dir for this group.\n efrotools.run('mkdir -p \"' + assets_src_dst + '\"')\n efrotools.run(\n 'rsync --recursive --include \"*.py\"'\n ' --exclude __pycache__ --include \"*/\" --exclude \"*\" \"'\n + build['pylib'] + '/\" \"' + assets_src_dst + '\"')\n\n # Prune a bunch of modules we don't need to cut\n # down on size.\n prune = [\n 'config-*', 'idlelib', 'lib-dynload', 'lib2to3',\n 'multiprocessing', 'pydoc_data', 'site-packages',\n 'ensurepip', 'tkinter', 'wsgiref', 'distutils',\n 'turtle.py', 'turtledemo', 'test', 'sqlite3/test',\n 'unittest', 'dbm', 'venv', 'ctypes/test', 'imaplib.py',\n '_sysconfigdata_*'\n ]\n efrotools.run('cd \"' + assets_src_dst + '\" && rm -rf ' +\n ' '.join(prune))\n\n # Some minor filtering to system scripts:\n # on iOS/tvOS, addusersitepackages() leads to a crash\n # due to _sysconfigdata_dm_ios_darwin module not existing,\n # so let's skip that.\n fname = f'{assets_src_dst}/site.py'\n txt = efrotools.readfile(fname)\n txt = efrotools.replace_one(\n txt,\n ' known_paths = addusersitepackages(known_paths)',\n ' # efro tweak: this craps out on ios/tvos.\\n'\n ' # (and we don\\'t use it anyway)\\n'\n ' # known_paths = addusersitepackages(known_paths)')\n efrotools.writefile(fname, txt)\n\n # Copy in a base set of headers (everything in a group should\n # be using the same headers)\n efrotools.run(f'cp -r \"{build[\"headers\"]}\" \"{header_dst}\"')\n\n # Clear whatever pyconfigs came across; we'll build our own\n # universal one below.\n efrotools.run('rm ' + header_dst + '/pyconfig*')\n\n # Write a master pyconfig header that reroutes to each\n # platform's actual header.\n with open(header_dst + '/pyconfig.h', 'w') as hfile:\n hfile.write(\n '#if BA_OSTYPE_MACOS\\n'\n '#include \"pyconfig-macos.h\"\\n\\n'\n '#elif BA_OSTYPE_IOS\\n'\n '#include \"pyconfig-ios.h\"\\n\\n'\n '#elif BA_OSTYPE_TVOS\\n'\n '#include \"pyconfig-tvos.h\"\\n\\n'\n '#elif BA_OSTYPE_ANDROID and defined(__arm__)\\n'\n '#include \"pyconfig-android_arm.h\"\\n\\n'\n '#elif BA_OSTYPE_ANDROID and defined(__aarch64__)\\n'\n '#include \"pyconfig-android_arm64.h\"\\n\\n'\n '#elif BA_OSTYPE_ANDROID and defined(__i386__)\\n'\n '#include \"pyconfig-android_x86.h\"\\n\\n'\n '#elif BA_OSTYPE_ANDROID and defined(__x86_64__)\\n'\n '#include \"pyconfig-android_x86_64.h\"\\n\\n'\n '#else\\n'\n '#error unknown platform\\n\\n'\n '#endif\\n')\n\n # Now copy each build's config headers in with unique names.\n cfgs = [\n f for f in os.listdir(build['headers'])\n if f.startswith('pyconfig')\n ]\n\n # Copy config headers to their filtered names.\n for cfg in cfgs:\n out = cfg.replace('pyconfig', 'pyconfig-' + build['name'])\n if cfg == 'pyconfig.h':\n\n # For platform's root pyconfig.h we need to filter\n # contents too (those headers can themselves include\n # others; ios for instance points to a arm64 and a\n # x86_64 variant).\n contents = efrotools.readfile(build['headers'] + '/' + cfg)\n contents = contents.replace('pyconfig',\n 'pyconfig-' + build['name'])\n efrotools.writefile(header_dst + '/' + out, contents)\n else:\n # other configs we just rename\n efrotools.run('cp \"' + build['headers'] + '/' + cfg +\n '\" \"' + header_dst + '/' + out + '\"')\n\n # Copy in libs. If the lib gave a specific install name,\n # use that; otherwise use name.\n targetdir = lib_dst + '/' + build.get('libinst', build['name'])\n efrotools.run('rm -rf \"' + targetdir + '\"')\n efrotools.run('mkdir -p \"' + targetdir + '\"')\n for lib in build['libs']:\n efrotools.run('cp \"' + lib + '\" \"' + targetdir + '\"')\n\n print('Great success!')","def test_index_libraries(self):\n result1 = self._create_library(slug=\"test-lib-index-1\", title=\"Title 1\", description=\"Description\")\n result2 = self._create_library(slug=\"test-lib-index-2\", title=\"Title 2\", description=\"Description\")\n\n for result in [result1, result2]:\n library_key = LibraryLocatorV2.from_string(result['id'])\n response = ContentLibraryIndexer.get_items([library_key])[0]\n\n assert response['id'] == result['id']\n assert response['title'] == result['title']\n assert response['description'] == result['description']\n assert response['uuid'] == result['bundle_uuid']\n assert response['num_blocks'] == 0\n assert response['version'] == result['version']\n assert response['last_published'] is None\n assert response['has_unpublished_changes'] is False\n assert response['has_unpublished_deletes'] is False","def makeProjects(self, *versions):\n baseDirectory = FilePath(self.mktemp())\n baseDirectory.createDirectory()\n for version in versions:\n self.makeProject(version, baseDirectory)\n return baseDirectory","def create_init_files(self, app_label, model_names, models):\n model_name_slugs = [\"%s_views\" % (self.camel_to_slug(model_name)) for model_name in model_names]\n model_names_dict = {self.camel_to_slug(model.__name__): self.camel_to_slug(self.model_name_plural(model)) for\n model in models}\n for folder_name in [\"views\", \"urls\"]:\n file_path = \"%s/%s/__init__.py\" % (app_label, folder_name)\n template_path = \"django_baker/__init__%s\" % folder_name\n self.create_file_from_template(file_path, template_path, {\"app_label\": app_label,\n \"model_name_slugs\": model_name_slugs,\n \"model_names_dict\": model_names_dict\n })","def mk_rg3(self):\n pass","def main():\n # Create / clean output dir\n if os.path.isdir(OUT_DIR):\n shutil.rmtree(OUT_DIR)\n os.mkdir(OUT_DIR)\n\n # Write all assets to the directory\n for fname, bb in create_assets().items():\n filename = os.path.join(OUT_DIR, fname)\n dirname = os.path.dirname(filename)\n if not os.path.isdir(dirname):\n os.makedirs(dirname)\n with open(filename, \"wb\") as f:\n f.write(bb)","def __init__(self):\n self._ll = LowLevelLibs()\n self._lib = self._ll.phe","def __init__(self, lib_dir, dist_dir, windows_exe_files=[],\n console_exe_files=[], service_exe_files=[],\n comserver_files=[], lib_files=[]):\n self.lib_dir = lib_dir\n self.dist_dir = dist_dir\n if not self.dist_dir[-1] in \"\\\\/\":\n self.dist_dir += \"\\\\\"\n self.name = AppName\n self.lname = AppName.lower()\n self.version = AppVersion\n self.windows_exe_files = [self.chop(p) for p in windows_exe_files]\n self.console_exe_files = [self.chop(p) for p in console_exe_files]\n self.service_exe_files = [self.chop(p) for p in service_exe_files]\n self.comserver_files = [self.chop(p) for p in comserver_files]\n self.lib_files = [self.chop(p) for p in lib_files]\n self.icon = os.path.abspath(r'doc\\icon\\favicon.ico')","def _setup(self):\n mkdir_p(self.output_folder)\n if self.symlink_dir:\n mkdir_p(self.symlink_dir)\n try:\n selected_versions = self._resolve_dependencies()\n if selected_versions:\n self._write_lock(selected_versions)\n print('\\n\\nVersions Selected for downloading:\\n')\n print('\\t' + '\\n\\t'.join(['{}: {}'.format(req, ver) for req, ver in selected_versions.items()]) + '\\n')\n for pkg_name, version in selected_versions.items():\n pkg_metadata = self._get_metadata(pkg_name)\n version_metadata = pkg_metadata.get('versions', dict()).get(str(version), dict())\n self._download_package(version_metadata)\n except (RequirementMatchError, DependencyError) as e:\n print(e.message)\n return self.created()","def get_libraries(self, archs: list[str]):\n libraries = self.ScopedLibraryDict.get(\"common\", []).copy()\n\n for arch in archs:\n libraries + self.ScopedLibraryDict.get(arch, []).copy()\n return list(set(libraries))","def makeProjects(self, *versions):\n baseDirectory = FilePath(self.mktemp())\n for version in versions:\n self.makeProject(version, baseDirectory)\n return baseDirectory","def create_aiida_project_environment(self):\n try:\n self.create_folder_structure()\n self.build_python_environment()\n self.install_packages_from_index()\n except Exception:\n self.exit_on_exception()\n raise\n self.create_spec_entry()","def create_packages(self):\n if not self.rewrite:\n # The extra package structure is only required for vendored code used via import rewrites.\n return\n\n for index, _ in enumerate(self._subpath_components):\n relpath = _PACKAGE_COMPONENTS + self._subpath_components[: index + 1] + [\"__init__.py\"]\n touch(os.path.join(self.ROOT, *relpath))","def setup_lib(CLIB):\n # {{ SETUP_LIB }}","def gen_library(self):\n newlibrary = self.newlibrary\n whelpers.add_all_helpers(newlibrary.symtab)\n\n self.function_index = newlibrary.function_index\n self.class_map = newlibrary.class_map\n\n self.instantiate_all_classes(newlibrary.wrap_namespace)\n self.update_templated_typemaps(newlibrary.wrap_namespace)\n self.gen_namespace(newlibrary.wrap_namespace)","def create_main_dir(self):\n\n set_of_dirs= [ self.root_laas_ws,\n self.root_laas_ws+'/src',\n self.root_laas_ws+'/install']\n \n # Creates set_of_dirs if they do not exist\n for a_dir in list_of_dirs:\n if not os.path(a_dir).is_dir():\n os.makedirs(a_dir,0o777,True)","def init():\n run('mkdir -p %(releases_dir)s' % env)\n execute(cleanup)\n execute(create_directories)","def shared_temporal_libraries(self):\n foo='shared_temporal_libraries () {\\n'\n foo+='#bring or delete necessary temporary libraries\\n'\n foo+=' e=1\\n' #initialize exit status as error\n if self.shared:\n cmd=sharedexe+' -a \"'+self.shared+'\" -b $$ -c $1' #$1== _PREPARE_ or _CLEANUP_\n foo+=' if '+cmd+'; then e=0;fi\\n'\n else:\n foo+=' echo \"no shared temporal libraries to $1\" && e=0\\n'\n foo+=' return $e\\n'\n foo+='}'\n return foo","def link_dependencies(self):\n\n # External libraries\n references = self.tree.xpath('//ns:ProjectReference', namespaces=self.ns)\n if references:\n self.cmake.write('# Link with other dependencies.\\n')\n self.cmake.write('target_link_libraries(${PROJECT_NAME} ')\n for ref in references:\n reference = str(ref.get('Include'))\n path_to_reference = os.path.splitext(ntpath.basename(reference))[0]\n lib = os.path.splitext(ntpath.basename(reference))[0]\n if lib == 'g3log':\n lib += 'ger' # To get \"g3logger\"\n self.cmake.write(lib + ' ')\n message = 'External library found : %s' % path_to_reference\n send(message, '')\n self.cmake.write(')\\n')\n\n # Additional Dependencies\n dependencies = self.tree.xpath('//ns:AdditionalDependencies', namespaces=self.ns)\n if dependencies:\n listdepends = dependencies[0].text.replace('%(AdditionalDependencies)', '')\n if listdepends != '':\n send('Additional Dependencies = %s' % listdepends, 'ok')\n windepends = []\n for d in listdepends.split(';'):\n if d != '%(AdditionalDependencies)':\n if os.path.splitext(d)[1] == '.lib':\n windepends.append(d)\n if windepends:\n self.cmake.write('if(MSVC)\\n')\n self.cmake.write(' target_link_libraries(${PROJECT_NAME} ')\n for dep in windepends:\n self.cmake.write(dep + ' ')\n self.cmake.write(')\\n')\n self.cmake.write('endif(MSVC)\\n')\n else: # pragma: no cover\n send('No dependencies.', '')","def __init__(self):\n self._ll = LowLevelLibs()\n self._lib = self._ll.pythia","def make_libfile():\n # wfc3_obsmodes_uvis\n wfc3_uvis = [\n \"f218w\",\n \"f225w\",\n \"f275w\",\n \"f336w\",\n \"f390m\",\n \"f390w\",\n \"f410m\",\n \"f438w\",\n \"f467m\",\n \"f475w\",\n \"f547m\",\n \"f555w\",\n \"f606w\",\n \"f621m\",\n \"f625w\",\n \"f689m\",\n \"f763m\",\n \"f775w\",\n \"f814w\",\n \"f845m\",\n ]\n\n wfc3_ir = [\n \"f098m\",\n \"f105w\",\n \"f110w\",\n \"f125w\",\n \"f127m\",\n \"f139m\",\n \"f140w\",\n \"f153m\",\n \"f160w\",\n ]\n\n wfpc2 = [\n \"f122m\",\n \"f157w\",\n \"f336w\",\n \"f410m\",\n \"f467m\",\n \"f547m\",\n \"f439w\",\n \"f569w\",\n \"f675w\",\n \"f791w\",\n \"f170w\",\n \"f185w\",\n \"f218w\",\n \"f255w\",\n \"f300w\",\n \"f380w\",\n \"f555w\",\n \"f622w\",\n \"f450w\",\n \"f606w\",\n \"f702w\",\n \"f814w\",\n ]\n\n acs_wfc = [\n \"f435w\",\n \"f475w\",\n \"f550m\",\n \"f555w\",\n \"f606w\",\n \"f625w\",\n \"f775w\",\n \"f814w\",\n ]\n # galex\n galex = [\"fuv\", \"nuv\"]\n\n # Open hd5 file for writing\n hf = h5py.File(__ROOT__ + \"filters.hd5\", \"w\")\n\n # Create group for nice hierarchical structure\n f = hf.create_group(\"filters\")\n\n # Define arrays for \"contents\" / descriptive information\n tablenames = []\n observatories = []\n instruments = []\n names = []\n norms = []\n cwaves = []\n pwaves = []\n comments = []\n\n # Loop through WFC3_UVIS filters\n for filt in wfc3_uvis:\n\n # define uvis 1 and uvis2 modes\n mode_1 = \"wfc3, uvis1, \" + filt\n mode_2 = \"wfc3, uvis2, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_WFC3_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFC3\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of uvis1 and uvis2\")\n\n # Loop through WFC3_IR filters\n for filt in wfc3_ir:\n\n # define ir mode\n mode = \"wfc3, ir, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp = stsyn.band(mode)\n\n # extract the wavelength array\n wave = bp.waveset\n\n # define the filter name\n filter_name = \"HST_WFC3_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFC3\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"\")\n\n # Loop through WFPC2 filters\n for filt in wfpc2:\n\n # define chips 1, 2, 3, 4 modes\n mode_1 = \"wfpc2, 1, \" + filt\n mode_2 = \"wfpc2, 2, \" + filt\n mode_3 = \"wfpc2, 3, \" + filt\n mode_4 = \"wfpc2, 4, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n bp_3 = stsyn.band(mode_3)\n bp_4 = stsyn.band(mode_4)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave), bp_3(wave), bp_4(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_WFPC2_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"WFPC2\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of 1, 2, 3, 4\")\n\n # Loop through ACS filters\n for filt in acs_wfc:\n\n # define wfc1, wfc2 modes\n mode_1 = \"acs, wfc1, \" + filt\n mode_2 = \"acs, wfc2, \" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp_1 = stsyn.band(mode_1)\n bp_2 = stsyn.band(mode_2)\n\n # extract the wavelength array\n wave = bp_1.waveset\n\n # compute the average bandpass between uvis1 and uvis2\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\n\n # define the filter name\n filter_name = \"HST_ACS_WFC_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"HST\")\n instruments.append(\"ACS_WFC\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"avg of wfc1 and wfc2\")\n\n # Loop through GALEX filters:\n for filt in galex:\n # define ir mode\n mode = \"galex,\" + filt\n\n # pull bandpasses from stsynphot for the two uvis modes\n bp = stsyn.band(mode)\n\n # extract the wavelength array\n wave = bp.waveset\n\n # define the filter name\n filter_name = \"GALEX_\" + filt.upper()\n\n # build array of wavelength and throughput\n arr = np.array(\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\n dtype=[(\"WAVELENGTH\", \"float64\"), (\"THROUGHPUT\", \"float64\")],\n )\n\n # append dataset to the hdf5 filters group\n f.create_dataset(filter_name, data=arr)\n\n # generate filter instance to compute relevant info\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\n\n # populate contents lists with relevant information\n tablenames.append(filter_name)\n observatories.append(\"GALEX\")\n instruments.append(\"GALEX\")\n names.append(newfilt.name)\n norms.append(newfilt.norm.value)\n cwaves.append(newfilt.cl.value)\n pwaves.append(newfilt.lpivot.value)\n comments.append(\"\")\n\n # smash the contents arrays together\n contents = np.array(\n list(\n zip(\n tablenames,\n observatories,\n instruments,\n names,\n norms,\n cwaves,\n pwaves,\n comments,\n )\n ),\n dtype=[\n (\"TABLENAME\", \"S40\"),\n (\"OBSERVATORY\", \"S30\"),\n (\"INSTRUMENT\", \"S30\"),\n (\"NAME\", \"S10\"),\n (\"NORM\", \"<f8\"),\n (\"CWAVE\", \"<f8\"),\n (\"PWAVE\", \"<f8\"),\n (\"COMMENT\", \"S100\"),\n ],\n )\n\n # add the contents array as an hd5 dataset\n hf.create_dataset(\"content\", data=contents)\n\n # close the file\n hf.close()","def build_all(self):\n self.android_build()\n self.generate_patch_build('')\n self.generate_specs_build()\n self.generate_interfaces()","def init(cx):\n\n\n # create the folder structure\n for d in PROJECT_DIRS:\n cx.run(\"mkdir -p {}\".format(d))\n cx.run(\"touch {}/.keep\".format(d))","def init(self):\n # Create the default project files\n self.create_from_templates()\n\n # Add all the newly created files to the git staging area\n self.add_all_untracked()\n\n # Check that a compatible version of Python is available; install it if not\n self._pyenv.ensure_python(self.get_python_version())\n\n # Create virtualenv\n self._pyenv.create_virtualenv(self.name, self.get_python_version())","def _setup(self):\n self._raw_top_dir = os.path.join(self._snippets_dir,\"raw\",\"dynamic\")\n if not os.path.exists(self._raw_top_dir):\n os.mkdir(self._raw_top_dir)\n\n self._trec_top_dir = os.path.join(self._snippets_dir,\"trec\",\"dynamic\")\n if not os.path.exists(self._trec_top_dir):\n os.mkdir(self._trec_top_dir)\n\n self._temp_top_dir = os.path.join(self._snippets_dir,\"temp\",\"dynamic\")\n if not os.path.exists(self._temp_top_dir):\n os.mkdir(self._temp_top_dir)\n\n self._snippet_result_top_dir = os.path.join(self._snippets_dir,\"result\",\"dynamic\")\n if not os.path.exists(self._snippet_result_top_dir):\n os.mkdir(self._snippet_result_top_dir)\n\n self._snippet_index_top_dir = os.path.join(self._snippets_dir,\"index\",\"dynamic\")\n if not os.path.exists(self._snippet_index_top_dir):\n os.mkdir(self._snippet_index_top_dir)\n\n self._para_top_dir = os.path.join(self._snippets_dir,\"para\",\"dynamic\")\n if not os.path.exists(self._para_top_dir):\n os.mkdir(self._para_top_dir)","def add_lib(ctx, sources, library, folder, roles, lib_desc, lib_synopsis, datatype, no_file_check, replace, no_biomaj_env):\n\n if not sources:\n print(\"Nothing to do\")\n return\n\n if not library:\n if 'dbname' in os.environ:\n library = os.environ['dbname']\n else:\n raise Exception('No library defined. Use the --library option.')\n\n sources = check_input(sources, check_existence=(not no_file_check), use_biomaj_env=(not no_biomaj_env))\n\n r_roles = []\n if roles:\n print(\"Checking roles\")\n roles = roles.split(',')\n r_roles = get_roles(ctx.gi, roles)\n\n print(\"Adding to data library '\" + str(library) + \"'\")\n\n if not folder:\n folder = '/'\n dest = os.path.normpath(folder)\n dest = dest.split(os.sep)\n dest = [x for x in dest if x] # Remove empty string when sep at the begin or end, or multiple sep\n\n found_lib = get_library(ctx.gi, library, lib_desc, lib_synopsis)\n\n print(\"Preparing folders in library '\" + library + \"'\")\n\n dest_folder = create_tree(ctx.gi, found_lib, dest)\n\n check_existing(ctx.gi, found_lib, dest, sources, replace)\n\n print(\"Adding \" + str(len(sources)) + \" file(s) to the library '\" + library + \"'\")\n add_files(ctx.gi, found_lib, dest_folder, sources, r_roles, datatype)\n\n print(\"Done!\")","def create_library(self, org, library, user_id, fields, **kwargs):\n kwargs[\"fields\"] = fields\n kwargs[\"master_branch\"] = kwargs.get(\"master_branch\", ModuleStoreEnum.BranchName.library)\n kwargs[\"root_category\"] = kwargs.get(\"root_category\", \"library\")\n kwargs[\"root_block_id\"] = kwargs.get(\"root_block_id\", \"library\")\n locator = LibraryLocator(org=org, library=library, branch=kwargs[\"master_branch\"])\n return self._create_courselike(locator, user_id, **kwargs)","def run(self):\n self._make_lib_file_symbolic_links()\n self._copy_each_include_files_to_include_dir()\n self._make_dep_lib_file_sym_links_and_copy_include_files()\n self.setup_py.add_patchs_to_build_without_pkg_config(\n self.rpm.lib_dir, self.rpm.include_dir\n )\n self.setup_py.apply_and_save()\n self._build_and_install()","def __init__(self):\n self._ll = LowLevelLibs()\n self._lib = self._ll.foundation","def build(request):\n \n def get(name):\n return request.GET.get(name)\n def get_arr(name):\n val = get(name)\n if val:\n return val.split(\",\")\n else:\n return []\n\n require = get_arr(\"require\")\n exclude = get_arr(\"exclude\")\n excludeLibs = get_arr(\"excludeLibs\")\n requireLibs = get_arr(\"requireLibs\")\n download = get(\"download\")\n reset = get(\"reset\")\n client = get(\"client\")\n compression = get(\"compression\")\n\n dpdr = None\n global depender\n if settings.DEPENDER_DEBUG:\n dpdr = make_depender()\n else:\n dpdr = depender\n if reset == \"true\":\n depender = dpdr\n \n if compression is None:\n compression = dpdr.default_compression\n if settings.DEPENDER_DEBUG:\n compression = \"none\"\n\n if client == \"true\" and require.count(\"Depender.Client\") == 0:\n require.append(\"Depender.Client\")\n \n includes = dpdr.get_dependencies(require, exclude, requireLibs, excludeLibs)\n output = \"//No files included for build\"\n if len(includes) > 0:\n \n libraries_and_copyrights = dict()\n for i in includes:\n libraries_and_copyrights[i.library] = i.copyright\n\n output = \"\"\n for lib, copy in libraries_and_copyrights.iteritems():\n if len(copy) > 0:\n output += copy + \"\\n\"\n\n output += \"\\n//Contents: \"\n output += \", \".join([ i.name for i in includes ])\n output += \"\\n\\n\"\n \n location = request.META[\"SERVER_PROTOCOL\"].split(\"/\")[0].lower() + \"://\" + request.META[\"HTTP_HOST\"] + request.path\n args = request.META[\"QUERY_STRING\"]\n if args.find(\"download=\") >= 0:\n clean = []\n for arg in args.split(\"&\"):\n if arg.find(\"download=\") == -1:\n clean.append(arg)\n args = '&'.join(clean)\n\n output += \"//This lib: \" + location + '?' + args\n output += \"\\n\\n\"\n\n for i in includes:\n output += i.compressed_content[compression] + \"\\n\\n\"\n\n if client == \"true\":\n output += dpdr.get_client_js(includes, location)\n\n response = HttpResponse(output, content_type=\"application/x-javascript\")\n \n if (download == \"true\"):\n response['Content-Disposition'] = 'attachment; filename=built.js'\n return response","def test_list_available_libraries(self):\n _ = LibraryFactory.create(modulestore=self.store)\n all_libraries = self.tools.list_available_libraries()\n assert all_libraries\n assert len(all_libraries) == 1","def get_artifacts(self):\n\n self.clml_modules = list(\n filter(lambda mod: mod.type_key == \"clml\", self.libm.get_lib().imported_modules)\n )\n self.clml_builds[\"file_header\"] = [self.MakeFileHeader.substitute()]\n\n for cmod in self.clml_modules:\n (sub_module_name, clml_code) = CLMLGetSubModuleSrc(cmod).get_src()\n self.clml_builds[sub_module_name] = clml_code\n\n main_code = []\n main_code.append(\n \"\"\"\n std::vector<CLMLRunner> BuildModules(ToolArgs& args,\n cl_platform_id arg_platform,\n cl_context arg_context,\n cl_device_id arg_device_id,\n cl_command_queue arg_queue) {\n std::vector<CLMLRunner> runners;\"\"\"\n )\n for key, val in self.clml_builds.items():\n if key != \"file_header\":\n main_code.append(\n \"runners.push_back(\"\n + key\n + '(\"'\n + key\n + '\", args, arg_platform, arg_context, arg_device_id, arg_queue));'\n )\n main_code.append(\"return runners;}\")\n self.clml_builds[\"MainBuild\"] = main_code\n\n for key, val in self.clml_builds.items():\n self.gen_src.extend(val)\n\n return (self.get_clml_params(), self.gen_src)","def libs(self):\n return self['libs']","def set_up(self):\n self.path.state = self.path.gen.joinpath(\"state\")\n if self.path.state.exists():\n self.path.state.rmtree(ignore_errors=True)\n self.path.state.mkdir()\n\n for script in self.given.get(\"scripts\", []):\n script_path = self.path.state.joinpath(script)\n\n if not script_path.dirname().exists():\n script_path.dirname().makedirs()\n\n script_path.write_text(self.given[\"scripts\"][script])\n script_path.chmod(\"u+x\")\n\n for filename, contents in self.given.get(\"files\", {}).items():\n self.path.state.joinpath(filename).write_text(contents)\n\n self.python = hitchpylibrarytoolkit.project_build(\n \"commandlib\", self.path, self.given[\"python version\"]\n ).bin.python\n\n self.example_py_code = (\n ExamplePythonCode(self.python, self.path.state)\n .with_code(self.given.get(\"code\", \"\"))\n .with_setup_code(self.given.get(\"setup\", \"\"))\n )","def set_libraries(self, lst):\n self.__libraries = lst","def on_libRoot(self):\n self.rf_libTree()\n self.rf_libPath()\n self.rf_libFileName()\n self.rf_delInfo()","def initFilters(CONFIG):\n\t#### String containing all the preLibraries file name\n\tpreLibraries = findFile(\"classification_result/prelibraries/TE\", \"*.fasta\")\n\n\t#### String containing all the preLibraries file name\n\tnoCatLibrarie = findFile(\"classification_result/prelibraries/\", \"noCat.fasta\")\n\n\tlistPrelibraries = []\n\t#### dictionnaries that will contains all the id's sequences for concerned libraries\n\tdicoLibraries={\"autonomousLib\":[], \"totalTELib\":[], \"totalRepeatLib\":[]}\n\n\tlistPrelibraries.append(noCatLibrarie[0])\n\t#### Add all the name of prelibraries in listPrelibraries\n\tfor file in preLibraries:\n\t\tlistPrelibraries.append(file)\n\n\t#### Dictionnary that restain the final classification for a given sequence (helpfull for the intermediateLibraries)\n\tdicoFinalClassif={}\n\t#### Parse all the prelibrary\n\tprint(\"####\tApply the filters to create the intermediate libraries\")\n\tcreateIntermediateLibraries(listPrelibraries, dicoLibraries, CONFIG, dicoFinalClassif)\n\n\t#### List containing all the intermediate librarie file name\n\tintermediateLibraries = findFile(\"classification_result/intermediateLibraries\", \"*.fasta\")\n\n\tprint(\"####\tApply the cd-hit-est on the intermediate libraries\")\n\tapplyCDHIT(intermediateLibraries)\n\n\tretriveFinalLibrarieSequences(intermediateLibraries, CONFIG, dicoFinalClassif, dicoLibraries)\n\n\tprint(\"####\tCreation of the three final libraries\")\n\tcreateFinalLibraries(intermediateLibraries, dicoLibraries)\n\n\tprint(\"Number of sequences in autonomousTE : {nbAutonomous}\\nNumber of sequences in totalTE : {nbTotalTE}\\nNumber of sequences in totalRepeatLib : {nbRepeated}\".format(\\\n\tnbAutonomous=len(dicoLibraries[\"autonomousLib\"]), nbTotalTE=len(dicoLibraries[\"totalTELib\"]), nbRepeated=len(dicoLibraries[\"totalRepeatLib\"])))","def create_mp3():\n\n #TODO: les roles ne devraient pas etre en dur\n list_all_roles = [\n [],\n [\"morgan\"],\n [\"oberon\"],\n [\"mordred\"],\n [\"morgan\", \"oberon\"],\n [\"morgan\", \"mordred\"],\n [\"oberon\", \"mordred\"],\n [\"morgan\", \"oberon\", \"mordred\"]\n ]\n\n for list_roles in list_all_roles:\n\n list_mp3 = [\"init.mp3\", \"serv_mord.mp3\"]\n if \"oberon\" in list_roles:\n list_mp3.append(\"oberon.mp3\")\n list_mp3.append(\"red_identi.mp3\")\n\n if \"morgan\" in list_roles:\n list_mp3.append(\"add_per_mor.mp3\")\n\n list_mp3.append(\"serv_mord.mp3\")\n if \"mordred\" in list_roles:\n list_mp3.append(\"mordred.mp3\")\n list_mp3.extend([\"merlin_identi.mp3\", \"end.mp3\"])\n\n mp3_combined = AudioSegment.empty()\n for mp3 in list_mp3:\n mp3_combined += AudioSegment.from_mp3(\"resources/{}\".format(mp3))\n\n mp3_combined.export(\"resources/_{}.mp3\".format('-'.join(sorted(list_roles))), format=\"mp3\")","def create_assets():\n assets = {}\n\n # Load all static files\n for root, dirs, files in os.walk(STATIC_DIR):\n for fname in files:\n filename = os.path.join(root, fname)\n with open(filename, \"rb\") as f:\n assets[os.path.relpath(filename, STATIC_DIR)] = f.read()\n\n # Collect pages\n pages = {}\n for fname in os.listdir(PAGES_DIR):\n if fname.lower().endswith(\".md\"):\n name = fname.split(\".\")[0].lower()\n with open(os.path.join(PAGES_DIR, fname), \"rb\") as f:\n md = f.read().decode()\n pages[name] = Page(name, md)\n\n # todo: Collect blog posts\n\n # Get template\n with open(os.path.join(THIS_DIR, \"template.html\"), \"rb\") as f:\n html_template = f.read().decode()\n\n with open(os.path.join(THIS_DIR, \"style.css\"), \"rb\") as f:\n css = f.read().decode()\n css += \"/* Pygments CSS */\\n\" + HtmlFormatter(style=\"vs\").get_style_defs(\n \".highlight\"\n )\n\n # Generate pages\n year = datetime.now().year\n for page in pages.values():\n page.prepare(pages.keys())\n title = TITLE if page.name == \"index\" else TITLE + \" - \" + page.name\n menu = create_menu(page)\n html = html_template.format(\n title=title, style=css, body=page.to_html(), menu=menu, year=year\n )\n print(\"generating\", page.name + \".html\")\n assets[page.name + \".html\"] = html.encode()\n\n # Fix backslashes on Windows\n for key in list(assets.keys()):\n if \"\\\\\" in key:\n assets[key.replace(\"\\\\\", \"/\")] = assets.pop(key)\n\n return assets","def setup():\n print('...')\n # Make sure dirs exist\n for directory in [DATA_DIR, DATA_INPUT_DIR, DATA_OUTPUT_DIR]:\n os.makedirs(directory, exist_ok=True)","def _create_assets(self):\n\n assets = Environment(self.app)\n # jQuery is served as a standalone file\n jquery = Bundle('js/jquery-*.min.js', output='gen/jquery.min.js')\n # JavaScript is combined into one file and minified\n js_all = Bundle('js/js_all/*.js',\n filters='jsmin',\n output='gen/app.min.js')\n # SCSS (Sassy CSS) is compiled to CSS\n scss_all = Bundle('scss/app.scss',\n filters='libsass',\n output='gen/app.css')\n assets.register('jquery', jquery)\n assets.register('js_all', js_all)\n assets.register('scss_all', scss_all)\n return assets","def write_inits(project_name, root_dir):\r\n \r\n #Create our file paths first...\r\n test_init_path = get_file_path(root_dir, \"tests\", \"__init__.py\")\r\n project_init_path = get_file_path(root_dir, project_name, \"__init__.py\")\r\n \r\n #Write the test_init file first\r\n test_init = open(test_init_path, 'w')\r\n test_init.close()\r\n print_file(test_init_path)\r\n \r\n #Write the NAME_init second\r\n project_init = open(project_init_path, 'w')\r\n project_init.close()\r\n print_file(project_init_path)","def build():","def make(config):\n # Create child folders\n for func in (create_basic_structure,\n copy_resources,\n copy_databases,\n copy_libraries,\n copy_security,\n copy_app_actions,\n copy_pages,\n create_application_info_file,\n replace_all_guids):\n\n INFO(\"\")\n INFO(\"+\"*70)\n INFO(\"\")\n func(config)","def create_intermediate_files():\n\n dirs = (DIR_PAGE, DIR_SRGB, DIR_VTI, DIR_TIFF,\n DIR_BACK, DIR_TEXT, DIR_FINAL)\n \n for dir in dirs:\n try:\n os.mkdir(os.path.join(cwd, dir))\n except OSError, e:\n print 'directory (', dir, ') already exists'","def __init__(self):\n self._ll = LowLevelLibs()\n self._lib = self._ll.ratchet","def __init__(self):\n self._ll = LowLevelLibs()\n self._lib = self._ll.ratchet","def get_libraries(name_only=False):\n\n libs = list()\n\n dtf_db = sqlite3.connect(DTF_DB)\n cur = dtf_db.cursor()\n\n # This just returns the name\n if name_only:\n\n sql = ('SELECT name '\n 'FROM libraries ')\n\n for lib in cur.execute(sql):\n libs.append(lib[0])\n\n # This returns a list of items\n else:\n\n sql = ('SELECT name, version, '\n 'about, author '\n 'FROM libraries '\n 'ORDER BY name')\n\n cur.execute(sql)\n\n while True:\n\n item = dtf.core.item.Item()\n line = cur.fetchone()\n if line is None:\n break\n\n item.type = dtf.core.item.TYPE_LIBRARY\n item.name = line[0]\n item.version = line[1]\n item.about = line[2]\n item.author = line[3]\n\n libs.append(item)\n\n return libs","def initialize():\n\n # create plugin locations\n for p in (cache_path, config_path, data_path):\n p.mkdir(parents=False, exist_ok=True)","def wheels():\n with lcd(env.local_path):\n put('./requirements.txt', '/srv/build/wheel_requirements.txt')\n put('./etc/base_image/image_requirements.txt',\n '/srv/build/requirements.txt')\n\n with cd('/srv/build/wheelhouse'):\n run('rm -rf *.whl')\n\n compose(cmd='-f service.yml -p %s run --rm wheel-factory' %\n env.project_name, path='/srv/build')","def check_init_files_and_folders():\n\t#['cascade_wimb_bus_front_100_stages_1000_pos_3000_neg.xml', 'cascade_wimb_bus_front_33_stages_1000_pos_3000_neg_wrong.xml', 'color_detect_2.py', 'dedupe.py', 'detect_image_group_ku.py', 'detect_shape_5.py', 'get_cam_id_2.py', 'get_image_8.py', 'gui_hsv.py', 'knaps.py', 'knapsack_2.py', 'maps.html', 'program_detect_rectangle.zip', 'start_capture.py']\n\tfile_list=[\n\t#'cascade_wimb_bus_front_100_stages_1000_pos_3000_neg.xml', \n\t'models/cascade_wimb_bus_front_33_stages_1000_pos_3000_neg_wrong.xml', \n\t#'color_detect_2.py', \n\t#'dedupe.py', \n\t'detect_bus_haar_group.py', \n\t#'detect_shape_5.py', \n\t'get_cam_detail.py', \n\t'get_image.py', \n\t#'gui_hsv.py', \n\t#'knaps.py', \n\t#'knapsack_2.py', \n\t#'maps.html', \n\t#'program_detect_rectangle.zip', \n\t'start_wimb.py',\n\t'g.php',\n\t]\n\tdirectory_list=[\n\t'images',\n\t'images_bgs',\n\t'images_bgs_mask',\n\t#'images_bgs_result',\n\t'images_color',\n\t'images_haar',\n\t'images_haar_result',\n\t'images_number',\n\t'images_number_result',\n\t'models',\n\t'images_old',\n\t'text_number',\n\t]\n\t\n\tfor file_name in file_list: print 'file '+file_name+' existed: '+str(os.path.isfile(file_name))\n\tfor directory_name in directory_list: \n\t\tprint 'directory '+directory_name+' existed: '+str(os.path.isdir(directory_name))\n\t\tif not os.path.isdir(directory_name): \n\t\t\tos.makedirs(directory_name)\n\t\tif \"images\" in directory_name: shutil.copy(path+'/g.php',path+'/'+directory_name+'/g.php')","def bake(self, apps_and_models):\n for app_label, models in iteritems(apps_and_models):\n model_names = {model.__name__: self.get_field_names_for_model(model) for model in models}\n self.create_directories(app_label)\n self.create_init_files(app_label, model_names.keys(), models)\n self.remove_empty_startapp_files(app_label)\n for file_name in [\"forms\", \"admin\", \"serializers\"]:\n file_path = \"%s/%s.py\" % (app_label, file_name)\n template_path = \"django_baker/%s\" % (file_name)\n self.create_file_from_template(file_path, template_path, {\"model_names\": model_names})\n for model in models:\n model_attributes = self.model_attributes(app_label, model)\n self.create_files_from_templates(model_attributes)","def init(self):\n\n # create directories\n self.createDirectory(\"src\")\n list_directories_name = {\n \"Models\": True,\n \"DTOs\": True,\n \"Repositories\": True,\n \"Services\": True,\n \"Mappeurs\": True,\n \"Ressources\": True,\n \"Logs\": False,\n \"Parsers\": False,\n \"docker\": False,\n \"Enums\": False,\n \"Config\": False,\n }\n\n for directory_name in list_directories_name:\n self.createDirectory(\"src/\" + directory_name)\n\n self.createDirectory(\"src/Logs\")\n open(\"src/Logs/debug.log\", \"w\").close()\n open(\"src/Logs/info.log\", \"w\").close()\n open(\"src/Logs/error.log\", \"w\").close()\n\n # test directories\n self.createDirectory(\"Tests\")\n for directory_name in list_directories_name.keys():\n if list_directories_name[directory_name]:\n self.createDirectory(\"Tests/\" + directory_name)\n\n # helpers Test\n path = self.getPathFileInStatic(\"helpersTest.py\")\n shutil.copy(path, \"Tests/helpersTest.py\")\n\n # Security config\n path = self.getPathFileInStatic(\"security.py\")\n shutil.copy(path, \"src/Config/SecurityConfig.py\")\n\n # Logger\n path = self.getPathFileInStatic(\"logger.py\")\n shutil.copy(path, \"src/Config/Logger.py\")\n\n self.createDirectory(\"Tests/Mocks\")\n\n self.writeAppFile()\n\n path = self.getPathFileInStatic(\"config.py\")\n shutil.copy(path, \"src/Config/ApplicationConfig.py\")\n self.info(\"[x] create config.py\")\n # shutil.copy(getPathFileInStatic(\"__init__.py\"), \"src/__init__.py\")\n # info(\"[x] create __init__.py\")\n path = self.getPathFileInStatic(\"server.py\")\n shutil.copy(path, \"server.py\")\n self.info(\"[x] create server.py\")\n path = self.getPathFileInStatic(\"docker-compose.test.yml\")\n shutil.copy(path, \"src/docker/docker-compose.test.yml\")\n self.info(\"[x] create docker-compose.test.yml\")","def prepare_artifacts(configs, jar_list):\n artifact_folder = os.path.join(configs[\"targetFolder\"],\n datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S'))\n print(\"Creating artifact folder {0}...\".format(artifact_folder))\n os.makedirs(artifact_folder)\n\n download_and_delete_jars(configs, artifact_folder, jar_list)\n copy_poms(configs, artifact_folder)\n gpg_sign(configs, artifact_folder)\n generate_checksum(artifact_folder)\n\n return artifact_folder","def create_book_objects(content):\n library = []\n for book in content:\n library.append(Book(book['Author'], book['Title'], book['Publisher'], book['Shelf'], book['Category'],\n book['Subject']))\n print('Your Library has been loaded.')\n return library","def add_installed_libraries(self, extra_libs = [\"SeleniumLibrary\",\n \"SudsLibrary\",\n \"RequestsLibrary\"]):\n\n libdir = os.path.dirname(robot.libraries.__file__)\n loaded = []\n for filename in os.listdir(libdir):\n if filename.endswith(\".py\") or filename.endswith(\".pyc\"):\n libname, ext = os.path.splitext(filename)\n if (libname.lower() not in loaded and\n not self._should_ignore(libname)):\n\n try:\n self.add(libname)\n loaded.append(libname.lower())\n except Exception as e:\n # need a better way to log this...\n self.log.debug(\"unable to add library: \" + str(e))\n\n # I hate how I implemented this, but I don't think there's\n # any way to find out which installed python packages are\n # robot libraries.\n for library in extra_libs:\n if (library.lower() not in loaded and\n not self._should_ignore(library)):\n try:\n self.add(library)\n loaded.append(library.lower())\n except Exception as e:\n self.log.debug(\"unable to add external library %s: %s\" % \\\n (library, str(e)))","def setup():\n\n p4_slackbots = model.Project(\"Merch Website\", \"http://76.176.109.127:6969/\", \"/static/img/p4_slackbots.png\",\n \"P4Slackbots\",\n [\"Abhijay Deevi\", \"Kevin Do\", \"Travis Medley\", \"Paul Bokelman\", \"Gavin Theriault\"],\n \"This project is a merch website that we created for our Youtube channels, \"\n \"GodlyGoats and \"\n \"Albertpani Compani. We have a lot of merch you can buy and other information.\")\n\n p4_hangman = model.Project(\"Music Website\", url_for('p4_hangman_bp.index'), \"/static/img/p4hangman.png\",\n \"P4 Hangman\",\n [\"Charlie Zhu\", \"Rohan Nallapati\", \"Rivan Nayak\", \"Sarah Xie\", \"Noah Pidding\"],\n \"This website includes a portfolio of our projects we worked on this trimester as well \"\n \"as a music section including three different genres of music with multiple examples \"\n \"and descriptions of each.\")\n\n p4_fruitycoders = model.Project(\"Photography Website\", \"google.com\", \"/static/img/p4_fruitycoders.png\",\n \"P4 fruitycoders\",\n [\"Sophie Lee\", \"Linda Long\", \"Maggie Killada\", \"Adam Holbel\", \"Wenshi Bao\"],\n \"Our website (Fruity Photos) features the history of photography, as well as the \"\n \"works \"\n \"and biographies of several famous photographers, such as Ansel Adams and Annie \"\n \"Leibovitz.\")\n\n \"\"\"p4_coderjoes = model.Project(\"CoderJoes Store\", url_for('p4_coderjoes_bp.index'), \"/static/img/p4_coderjoes.png\",\n \"P4 Guessers\",\n [\"Lola Bulkin\", \"Grace Le\", \"Ryan Moghaddas\", \"William Cherres\", \"Brayden Basinger\"],\n \"CoderJoes is a virtual store where you can find recipes, ideas, and descriptions, \"\n \"as well as a group portfolio of our work over the trimester.\")\"\"\"\n\n projects = [p4_slackbots, p4_hangman, p4_fruitycoders]#, p4_coderjoes\n period = model.Period(\"Period 4\", \"AP Principles of Computer Science - Python\", projects)\n return period","def _create_chain(class_type_list, kwargs_list):\n chain = None # module with preprocessing chain\n modules = [] # list of modules (not connected via preprocessing)\n for i, pre_id in enumerate(class_type_list):\n chain = CModule.create(\n pre_id, preprocess=chain, **kwargs_list[i])\n modules.append(CModule.create(pre_id, **kwargs_list[i]))\n return chain, modules","def generate(self, info):\n root = ET.Element(\"libs\")\n\n # Set target\n target = ET.SubElement(root, \"target\")\n target.text = info.target\n\n # Set time info\n time_start = ET.SubElement(root, \"start_time\")\n time_start.text = info.start_time.strftime(\"%H-%m-%Y %H:%M:%S\")\n\n time_end = ET.SubElement(root, \"end_time\")\n time_end.text = info.end_time.strftime(\"%H-%m-%Y %H:%M:%S\")\n\n # WordPress info\n wordpress = ET.SubElement(root, \"wordpress\")\n wordpress.set(\"current_version\", info.wordpress_info.current_version)\n wordpress.set(\"last_version\", info.wordpress_info.latest_version)\n\n # Set CVE\n if info.wordpress_info.vulnerabilities:\n cves = ET.SubElement(wordpress, \"cves\")\n for cve in info.wordpress_info.vulnerabilities:\n xml_cve = ET.SubElement(cves, \"cve\")\n xml_cve.text = cve\n\n # Plugins info\n plugins = ET.SubElement(root, \"plugins\")\n for plugin in info.plugins:\n xml_plugin = ET.SubElement(plugins, \"plugin\")\n xml_plugin.text = plugin.plugin_name\n\n xml_plugin.set(\"current_version\", plugin.current_version)\n xml_plugin.set(\"last_version\", plugin.latest_version)\n xml_plugin.set(\"url\", plugin.plugin_uri)\n xml_plugin.set(\"outdated\", \"Yes\" if plugin.is_outdated else \"No\")\n\n # Set CVE\n if plugin.cves:\n cves = ET.SubElement(xml_plugin, \"cves\")\n for cve in plugin.cves:\n xml_cve = ET.SubElement(cves, \"cve\")\n xml_cve.text = cve\n\n # Set exploits\n if plugin.cves:\n exploits = ET.SubElement(xml_plugin, \"exploits\")\n for exploit in plugin.exploits:\n xml_exploit = ET.SubElement(exploits, \"exploits\")\n xml_exploit.text = exploit\n\n return root","def create_package(args, api, command_obj, resume=False):\n set_subcommand_file(args.output_dir)\n if resume:\n retrieve_subcommands()\n # read the metadata.json information\n message = ('Reading the metadata.json files.........\\n')\n u.log_message(message, log_file=session_file,\n console=args.verbosity)\n package_dir = args.package_dir\n output_dir = args.output_dir\n metadata_file = os.path.join(package_dir, METADATA_FILE)\n metadata = None\n\n with open(metadata_file) as metadata_handler:\n metadata = json.load(metadata_handler)\n # recurse into components/directories, if any\n if metadata.get(\"kind\") == \"package\" and 'components' in metadata:\n components = metadata.get(\"components\")\n for component in components:\n message = ('Inspecting component %s.........\\n' % component)\n u.log_message(message, log_file=session_file,\n console=args.verbosity)\n args.package_dir = os.path.join(package_dir, component)\n create_package(args, api, command_obj, resume=resume)\n args.package_dir = package_dir\n else:\n # create libraries or scripts\n imports = []\n category = str(metadata.get(\"category\", DFT_CATEGORY))\n if metadata.get(\"imports\") is not None:\n lib_imports = metadata.get(\"imports\")\n for lib_import in lib_imports:\n args.package_dir = os.path.join(package_dir, lib_import)\n if args.embed_libs:\n library_ref = create_package( \\\n args, api, command_obj, resume=resume)\n u.log_created_resources(\"imports\",\n output_dir, library_ref)\n else:\n try:\n # try to read the library id, if it is already there\n library_ref = read_library_id(os.path.join( \\\n output_dir, os.path.basename(args.package_dir)))\n except IOError:\n library_ref = create_package( \\\n args, api, command_obj, resume=resume)\n library_ref = read_library_id(os.path.join( \\\n output_dir, os.path.basename(args.package_dir)))\n imports.append(library_ref)\n args.package_dir = package_dir\n # read the metadata.json information\n message = ('Creating the %s.........\\n' % metadata.get(\"kind\"))\n u.log_message(message, log_file=session_file,\n console=args.verbosity)\n if metadata.get(\"kind\") in WHIZZML_RESOURCES:\n whizzml_code = os.path.normpath(os.path.join(args.package_dir, \\\n metadata.get(\"source_code\", \"%s.whizzml\" % \\\n metadata.get(\"kind\"))))\n if args.embed_libs and metadata.get(\"kind\") == WHIZZML_LIBRARY:\n return whizzml_code\n\n args.output_dir = os.path.join(output_dir, \\\n os.path.basename(package_dir))\n # creating command to create the resource\n command = COMMANDS[metadata.get(\"kind\")] % (whizzml_code,\n args.output_dir)\n command_args = command.split()\n bigml.util.check_dir(args.output_dir)\n\n # getting inputs and outputs for the script from metadata\n if \"inputs\" in metadata:\n inputs_file = os.path.join(args.output_dir, \"inputs.json\")\n u.write_to_utf8(inputs_file, json.dumps(metadata.get(\"inputs\")))\n command_args.extend([\"--declare-inputs\", inputs_file])\n if \"outputs\" in metadata:\n outputs_file = os.path.join(args.output_dir, \"outputs.json\")\n u.write_to_utf8(outputs_file, json.dumps(metadata.get(\"outputs\")))\n command_args.extend([\"--declare-outputs\", outputs_file])\n if \"description\" in metadata:\n desc_file = os.path.join(args.output_dir, \"description.txt\")\n u.write_to_utf8(desc_file, metadata.get(\"description\"))\n command_args.extend([\"--description\", desc_file])\n if metadata.get(\"name\"):\n command_args.extend([\"--name\", metadata.get(\"name\")])\n if args.tag:\n for tag in args.tag:\n command_args.extend([\"--tag\", tag])\n command_args.extend([\"--category\", category])\n\n # adding imports, if any\n if imports:\n if args.embed_libs:\n # imports to be embedded are in the same output directory\n command_args.extend( \\\n [\"--embedded-imports\", os.path.join(output_dir,\n \"imports\")])\n else:\n # imports to be refereced by ID\n command_args.extend([\"--imports\", \",\".join(imports)])\n command_args.extend([\"--verbosity\", str(args.verbosity)])\n command_obj.propagate(command_args)\n # u.add_api_context(command_args, args)\n if args.upgrade:\n command_args.extend([\"--upgrade\"])\n\n if resume:\n next_command = subcommand_list.pop()\n if different_command(next_command, command):\n resume = False\n u.sys_log_message(command, log_file=subcommand_file)\n execute_dispatcher(args=command_args)\n elif not subcommand_list:\n execute_dispatcher(args=['execute', '--resume'])\n resume = False\n else:\n u.sys_log_message(command, log_file=subcommand_file)\n execute_dispatcher(args=command_args)\n args.output_dir = output_dir\n return whizzml_code\n return \"\"","def _build_datasets(self):\n self._build_datasets_sis3302()\n self._build_datasets_sis3305()","def _setup(self):\n self._raw_dir = os.path.join(self._snippets_dir,\"raw\",\"static\")\n if not os.path.exists(self._raw_dir):\n os.mkdir(self._raw_dir)\n\n self._trec_dir = os.path.join(self._snippets_dir,\"trec\",\"static\")\n if not os.path.exists(self._trec_dir):\n os.mkdir(self._trec_dir)\n\n self._temp_dir = os.path.join(self._snippets_dir,\"temp\",\"static\")\n if not os.path.exists(self._temp_dir):\n os.mkdir(self._temp_dir)\n\n self._para_dir = os.path.join(self._snippets_dir,\"para\",\"static\")\n if not os.path.exists(self._para_dir):\n os.mkdir(self._para_dir)\n\n self._snippet_result_dir = os.path.join(self._snippets_dir,\"result\",\"static\")\n if not os.path.exists(self._snippet_result_dir):\n os.mkdir(self._snippet_result_dir)\n\n self._snippet_index_dir = os.path.join(self._snippets_dir,\"index\",\"static\")\n if not os.path.exists(self._snippet_index_dir):\n os.mkdir(self._snippet_index_dir)\n\n \n\n\n self._index_para = os.path.join(self._para_dir,\"index_para\")\n\n self._temp_query_para = os.path.join(self._para_dir,\"temp_query_para\")\n\n self._index_list = os.path.join(self._para_dir,\"static_index_list\")\n \n self._orf = os.path.join(self._snippet_result_dir,\"orf\")\n\n self._oqf = os.path.join(self._temp_dir,\"oqf\")\n \n self._temp_output = os.path.join(self._temp_dir,\"temp_output\")\n\n with open(self._index_list,\"w\") as f:\n f.write(self._snippet_index_dir+\"\\n\")\n\n self._temp_query_builder = IndriQueryFactory(count=10000,\n rule=self._retrieval_method)\n\n self._oqf_builder = IndriQueryFactory(count=30,\n rule=self._retrieval_method)","def main():\n os.makedirs(PATH)\n fetch_data()\n convert_to_json(model_list, 'models.json', is_model=True)\n convert_to_json(backend_list, 'backends.json')\n convert_to_json(type_list, 'types.json')\n convert_to_json(featurizer_list, 'featurizers.json')","def KengeLibrary(self, name, buildname=None, source = None, public_headers = None, **kargs):\n library_args = {}\n\n library_args[\"CPPPATH\"] = []\n\n if buildname is None:\n buildname = name\n\n if source is None:\n # User didn't provide any source files\n # explicitly, so we work out it form them\n # based on some hueristics.\n glob_list = []\n dirs = [\"include/interfaces/\", \"src/\", \"src/arch-%s/\" % env.arch]\n\t if self.test_lib == name:\n\t\tdirs.append(\"test/\")\n if self[\"BUILD_TESTS\"]:\n dirs += [\"test/\"]\n for src_ext in env.src_exts:\n for dir_ in dirs:\n glob_list.append(dir_ + \"*.\" + src_ext)\n else:\n glob_list = source\n\n libs = []\n \n if \"LIBS\" in kargs:\n if self[\"BUILD_TESTS\"]:\n kargs[\"LIBS\"].append(\"check\")\n for lib in kargs[\"LIBS\"]:\n libs.append(lib)\n if lib not in self.libs.keys():\n raise SCons.Errors.UserError, \"Library [%s] was looking for library [%s] but it doesn't exist \" \\\n \"in environment [%s]\\n This environment has: %s\" % (name, lib, self.name, self.libs.keys())\n\n del kargs[\"LIBS\"]\n\n # He we expand the glob to a list of files\n source_list = Flatten([src_glob(glob) for glob in glob_list])\n\n idl_files = [fn for fn in source_list if fn.endswith(\".idl4\")]\n reg_files = [fn for fn in source_list if fn.endswith(\".reg\")]\n\n # Now we go through everything in the kargs:\n for arg in kargs:\n if arg.startswith(\"EXTRA_\"):\n argname = arg[6:]\n library_args[argname] = self[argname] + kargs[arg]\n else:\n library_args[arg] = kargs[arg]\n\n # Generally this is the only public headers\n if public_headers is None:\n public_headers = [\"#libs/%s/include\" % name, \"#libs/%s/test\" % name]\n\n if len(idl_files) or len(reg_files):\n # Unless we have generated files\n public_headers.append(Dir(\".\").abspath + \"/include\")\n\n # Now if we are for real compiling stuff...\n cpp_path = copy.copy(self[\"CPPPATH\"])\n\tif self.test_lib:\n\t\tcpp_path.append(\"#libs/check/include\")\n \n # Make sure we include any of the libraries header file's\n for each in public_headers:\n cpp_path.append(each)\n\n # This ensure that any generated header files\n # Maybe move this somewhere else later though\n cpp_path.append(Dir('.').abspath + \"/src\") # Broken\n cpp_path.append(Dir('.').abspath + \"/include\")\n\n # Find any .idl4 files that should be generated\n for file in idl_files:\n gen_file = self.IDL4(file)\n\n # Generate any .reg files\n for file in reg_files:\n self.Reg(file)\n \n library_args[\"CPPPATH\"] += cpp_path + self.end_cpp_path # End cpp_path is a hack hack hack!\n \n # Now we just call the normal StaticLibrary with our simple defaults\n lib = self.StaticLibrary(buildname, source_list, **library_args)\n\n assert(len(lib) == 1)\n lib = lib[0]\n\n if self[\"FLINT_RUN\"]:\n for each in lib.children():\n if str(each).endswith(\".o\"):\n if str(each.children()[0]).endswith(\".c\") or \\\n str(each.children()[0]).endswith(\".cc\"):\n self.AddPreAction(each, \"$FLINTCOM\")\n\n # And construct our definition of the library\n # This should suck muhc much less... how about a class?\n lib = (public_headers, lib, \"#\" + os.path.dirname(lib.path), None, libs)\n return lib","def initialize_folders(self):\n logger.info('Initializing folders')\n create_folder(self.generator_folder)\n create_folder(self.data_folder)\n create_folder(self.input_folder)\n create_folder(self.filtered_folder)\n create_folder(self.model_folder)\n create_folder(self.build_folder)","def create(cls, user, master_mix, water, robot, tm300_8_tool, tm50_8_tool,\n volume, plates):\n with sql_connection.TRN as TRN:\n # Add the row to the process table\n process_id = cls._common_creation_steps(user)\n\n # Add the row to the library_prep_16s_process\n sql = \"\"\"INSERT INTO qiita.library_prep_16s_process\n (process_id, master_mix_id, tm300_8_tool_id,\n tm50_8_tool_id, water_id, processing_robot_id)\n VALUES (%s, %s, %s, %s, %s, %s)\n RETURNING library_prep_16s_process_id\"\"\"\n TRN.add(sql, [process_id, master_mix.id, tm300_8_tool.id,\n tm50_8_tool.id, water.id, robot.id])\n instance = cls(TRN.execute_fetchlast())\n\n for gdna_plate, primer_plate in plates:\n # Create the library plate\n plate_ext_id = '16S library - %s' % gdna_plate.external_id\n\n plate_config = gdna_plate.plate_configuration\n library_plate = plate_module.Plate.create(plate_ext_id,\n plate_config)\n gdna_layout = gdna_plate.layout\n primer_layout = primer_plate.layout\n for i in range(plate_config.num_rows):\n for j in range(plate_config.num_columns):\n well = container_module.Well.create(\n library_plate, instance, volume, i + 1, j + 1)\n composition_module.LibraryPrep16SComposition.create(\n instance, well, volume,\n gdna_layout[i][j].composition,\n primer_layout[i][j].composition)\n\n return instance","def create_database(self):\n\n try: \n connection = sqlite3.connect(self.filepath_render_database)\n pointer = connection.cursor()\n\n print(self.filepath_render_database)\n\n sql_instruction = \"\"\"\n CREATE TABLE IF NOT EXISTS render_information(\n \n object_type VARCHAR(255),\n name VARCHAR(255),\n radius REAL,\n polar_angle_min REAL,\n polar_anglel_max REAL,\n polar_angle_segments REAL,\n polar_angle_random_rad REAL,\n azimuth_angle_min REAL,\n azimuth_angle_max REAL,\n azimuth_angle_segments REAL,\n azimuth_angle_random_rad REAL,\n tracking_obj VARCHAR(255),\n segmentation VARCHAR(255)\n\n\n );\"\"\"\n pointer.execute(sql_instruction)\n connection.commit()\n connection.close()\n print(\"Creating render database file\")\n except:\n print(\"Was not able to create render database file\")\n \n try: \n connection = sqlite3.connect(self.filepath_object_database)\n pointer = connection.cursor()\n sql_instruction = \"\"\"\n CREATE TABLE IF NOT EXISTS object_information(\n obj_filepath VARCHAR(255),\n obj_name VARCHAR(255),\n obj_type VARCHAR(255),\n obj_scale_factor REAL,\n obj_location_x REAL,\n obj_location_y REAL,\n obj_location_z REAL,\n obj_rotation_x REAL,\n obj_rotation_y REAL,\n obj_rotation_z REAL,\n obj_amount_percent REAL,\n obj_material_path VARCHAR(255),\n obj_point_in_time VARCHAR(255),\n maximum_random_rotation_degree_z REAL,\n maximum_random_translation REAL,\n random_amount REAL\n );\"\"\"\n pointer.execute(sql_instruction)\n connection.commit()\n connection.close()\n print(\"Creating object database file\")\n except:\n print(\"Was not able to create object database file\")\n\n try: \n connection = sqlite3.connect(self.filepath_output_database)\n print(\"outputfilepath is:\", self.filepath_output_database)\n pointer = connection.cursor()\n sql_instruction = \"\"\"\n CREATE TABLE IF NOT EXISTS objects(\n image_id REAL,\n object_name VARCHAR(255),\n object_type VARCHAR(255),\n object_amount REAL,\n object_location_x REAL,\n object_location_y REAL,\n object_location_z REAL,\n object_rotation_x REAL,\n object_rotation_y REAL,\n object_rotation_z REAL,\n object_dimensions_x REAL,\n object_dimensions_y REAL,\n object_dimensions_z REAL\n );\"\"\"\n pointer.execute(sql_instruction)\n connection.commit()\n sql_instruction = \"\"\"\n CREATE TABLE IF NOT EXISTS camera_settings(\n image_id REAL,\n image_variation REAL,\n camera_name VARCHAR(255),\n camera_location_x REAL,\n camera_location_y REAL,\n camera_location_z REAL,\n camera_rotation_x REAL,\n camera_rotation_y REAL,\n camera_rotation_z REAL,\n camera_focal_length REAL,\n camera_polar_angle REAL,\n camera_azimuth_angle REAL\n );\"\"\"\n pointer.execute(sql_instruction)\n connection.commit()\n sql_instruction = \"\"\"\n CREATE TABLE IF NOT EXISTS light_settings(\n image_id REAL,\n image_variation REAL,\n light_name VARCHAR(255),\n light_location_x REAL,\n light_location_y REAL,\n light_location_z REAL,\n light_rotation_x REAL,\n light_rotation_y REAL,\n light_rotation_z REAL,\n light_intensity REAL,\n light_polar_angle REAL,\n light_azimuth_angle REAL\n );\"\"\"\n pointer.execute(sql_instruction)\n connection.commit()\n sql_instruction = \"\"\"\n CREATE TABLE IF NOT EXISTS general_settings(\n image_id REAL,\n render_type VARCHAR(255),\n render_frame REAL\n );\"\"\"\n pointer.execute(sql_instruction)\n connection.commit()\n sql_instruction = \"\"\"\n CREATE TABLE IF NOT EXISTS bounding_boxes(\n image_id REAL,\n image_variation REAL,\n object_name VARCHAR(255),\n object_type VARCHAR(255),\n min_x REAL,\n max_x REAL,\n min_y REAL,\n max_y REAL\n );\"\"\"\n pointer.execute(sql_instruction)\n connection.commit()\n connection.close()\n print(\"Creating output database file\")\n except:\n print(\"Was not able to create output database file\")","def build_context():\n threejs_url = 'https://www.gstatic.com/external_hosted/threejs-r98/'\n _publish.javascript(url=threejs_url + 'three.min.js')\n _publish.javascript(url=threejs_url + 'examples/js/controls/OrbitControls.js')\n return _js_builder.Js(mode=_js_builder.PERSISTENT)","def setup(conf, products, build=False):\n import distutils.sysconfig\n paths = {\n \"CPPPATH\": distutils.sysconfig.get_python_inc().split(),\n \"LIBPATH\": [],\n }\n libs = []\n dir = distutils.sysconfig.get_config_var(\"LIBPL\")\n if not dir in paths[\"LIBPATH\"]:\n paths[\"LIBPATH\"] += [dir]\n pylibrary = distutils.sysconfig.get_config_var(\"LIBRARY\")\n mat = re.search(\"(python.*)\\.(a|so|dylib)$\", pylibrary)\n if mat:\n libs.append(mat.group(1)) \n for w in (\" \".join([distutils.sysconfig.get_config_var(\"MODLIBS\"),\n distutils.sysconfig.get_config_var(\"SHLIBS\")])).split():\n mat = re.search(r\"^-([Ll])(.*)\", w)\n if mat:\n lL = mat.group(1)\n arg = mat.group(2)\n if lL == \"l\":\n if not arg in libs:\n libs.append(arg)\n else:\n if os.path.isdir(arg) and not arg in paths[\"LIBPATH\"]:\n paths[\"LIBPATH\"].append(arg)\n conf.env.PrependUnique(**paths)\n for lib in libs:\n if lib not in conf.env.libs[\"python\"]:\n conf.env.libs[\"python\"].append(lib)\n return {\"paths\": paths, \"libs\": {\"python\": libs}}","def _on_library_new(self, evt=None):\n \n # raise save dialog\n wildcard = \"Papyrus library format|*.papyrus\"\n dlg = wx.FileDialog(self, \"New Papyrus Library\", \"\", \"library.papyrus\", wildcard=wildcard, style=wx.FD_SAVE)\n if dlg.ShowModal() == wx.ID_OK:\n path = dlg.GetPath()\n dlg.Destroy()\n else:\n dlg.Destroy()\n return\n \n # init library\n try:\n core.Library(path, new=True)\n except:\n wx.Bell()\n dlg = mwx.MessageDlg(self, -1, \"Cannot create the library.\", \"Please check access permissions.\", \"Error\")\n dlg.ShowModal()\n dlg.Destroy()\n return\n \n # open library\n self.OpenDocuments([path])","def create_library(cls, service_uid, library_data):\n\n library_data = BaseView.helper_validate_library_data(\n service_uid=service_uid,\n library_data=library_data\n )\n _name = library_data.get('name')\n _description = library_data.get('description')\n _public = bool(library_data.get('public', False))\n _bibcode = library_data.get('bibcode', False)\n\n with current_app.session_scope() as session:\n try:\n # Make the library in the library table\n library = Library(name=_name,\n description=_description,\n public=_public)\n\n # If the user supplies bibcodes\n if _bibcode and isinstance(_bibcode, list):\n\n # Ensure unique content\n _bibcode = uniquify(_bibcode)\n current_app.logger.info('User supplied bibcodes: {0}'\n .format(_bibcode))\n library.add_bibcodes(_bibcode)\n elif _bibcode:\n current_app.logger.error('Bibcode supplied not a list: {0}'\n .format(_bibcode))\n raise TypeError('Bibcode should be a list.')\n\n user = session.query(User).filter_by(id = service_uid).one()\n\n # Make the permissions\n permission = Permissions(\n owner=True,\n )\n\n # Use the ORM to link the permissions to the library and user,\n # so that no commit is required until the complete action is\n # finished. This means any rollback will not leave a single\n # library without permissions\n library.permissions.append(permission)\n user.permissions.append(permission)\n\n session.add_all([library, permission, user])\n session.commit()\n\n current_app.logger.info('Library: \"{0}\" made, user_service: {1:d}'\n .format(library.name, user.id))\n\n library_dict = dict(\n name=library.name,\n id='{0}'.format(cls.helper_uuid_to_slug(library.id)),\n description=library.description,\n )\n # If they added bibcodes include in the response\n if hasattr(library, 'bibcode') and library.bibcode:\n library_dict['bibcode'] = library.get_bibcodes()\n return library_dict\n\n except IntegrityError as error:\n # Roll back the changes\n session.rollback()\n current_app.logger.error('IntegitryError, database has been rolled'\n 'back. Caused by user_service: {0:d}.'\n 'Full error: {1}'\n .format(user.id, error))\n # Log here\n raise\n except Exception:\n session.rollback()\n raise","def create_components():\n reset_uuid()\n # pylint: disable=protected-access\n controllers = []\n for compstr in dir(control):\n comp = getattr(control, compstr)\n if (compstr[0] != '_' and isclass(comp) and issubclass(comp, control._Controller)\n and compstr != 'Upload'):\n controllers.append(comp())\n\n for controller in controllers:\n assert COMPONENT_REGISTRY[controller._uuid] == controller\n\n visuals = []\n for compstr in dir(visual):\n comp = getattr(visual, compstr)\n if compstr[0] != '_' and isclass(comp) and issubclass(comp, visual._Visual):\n visuals.append(comp())\n\n for vis in visuals:\n assert COMPONENT_REGISTRY[vis._uuid] == vis\n\n htmls = []\n for compstr in dir(html):\n comp = getattr(html, compstr)\n if compstr[0] != '_' and isclass(comp) and issubclass(comp, html._HTML):\n htmls.append(comp())\n\n for htm in htmls:\n assert COMPONENT_REGISTRY[htm._uuid] == htm\n\n return controllers, visuals, htmls","def elinos_init():\n elinos_env = get_elinos_environment()\n\n solib_dirs = []\n\n # System libraries\n if None in (elinos_env[key] for key in (\"cdk\", \"target\")):\n warn(\"ELinOS system libraries will not be loaded\")\n else:\n solib_prefix = \"%s/%s\" % (elinos_env[\"cdk\"], elinos_env[\"target\"])\n solib_dirs += [\"%s/%s\" % (solib_prefix, \"lib\")]\n gdb.execute(\"set solib-absolute-prefix %s\" % solib_prefix)\n\n # Xenomai libraries. Those are optional, so have a lighter warning\n # if they cannot be located.\n if elinos_env[\"project\"] is None:\n warn(\"Xenomai libraries may not be loaded\")\n else:\n for dir in elinos_env['xenomai']:\n solib_dirs += [\"%s/%s\"\n % (dir, \"xenomai-build/usr/realtime/lib\")]\n\n if len(solib_dirs) != 0:\n gdb.execute(\"set solib-search-path %s\" % \":\".join(solib_dirs))","def init_objects():\n gravity = Gravity()\n planet_stencil = PlanetStencil()\n return gravity, planet_stencil","def create_allcomponents(self):\n\n # we store all components in a list/hash which we iterate for startup/shutdown/dumps debugging, and which can be used to lookup components\n self.components = MDictList()\n\n # setup log manager helper early so that log manager can receive messages (and queue them until startup)\n self.createappendcomp('logmanager', mlogger.MewloLogManager)\n\n # now update site state (log manager should catch this)\n self.set_statelabel(mconst.DEF_SITESTATE_INITIALIZE_START)\n\n # create (non-db-persistent) site settings -- these are set by configuration at runtime\n self.settings = self.createappendcomp('settings', MewloSettings)\n\n # database manager\n self.createappendcomp('dbmanager', mdbmanager_sqlalchemy.MewloDatabaseManagerSqlA)\n\n # component registry\n self.createappendcomp('registrymanager', mregistry.MewloRegistryManager)\n\n # signal dispatcher\n self.createappendcomp('signalmanager', msignal.MewloSignalManager)\n\n # rbac permission manager\n self.createappendcomp('rbacmanager', mrbac.MewloRbacManager)\n\n # create persistent(db) pack settings\n self.createappendcomp('packsettings', mdbsettings_pack.MewloSettingsDb_Pack)\n\n # collection of mewlo addon packs\n self.createappendcomp('packmanager', mpackmanager.MewloPackManager)\n\n # site addon manager\n #self.createappendcomp('siteaddonmanager', msiteaddon.MewloSiteAddonManager)\n\n # route manager\n self.createappendcomp('routemanager', mroute.MewloRouteManager)\n\n # navnode manager\n self.createappendcomp('navnodemanager', mnav.NavNodeManager)\n\n # template manager\n self.createappendcomp('templatemanager', mtemplate.MewloTemplateManager)\n\n # asset and alias manager\n self.createappendcomp('assetmanager', massetmanager.MewloAssetManager)\n\n # template helper (this is available inside template/views and provides helper functions like navigation menus, etc.)\n self.createappendcomp('templatehelper', mtemplatehelper.MewloTemplateHelper)\n\n # session manager\n self.createappendcomp('sessionmanager', msessionmanager.MewloSessionManager)\n\n # verification manager\n self.createappendcomp('verificationmanager', mverificationmanager.MewloVerificationManager)\n\n # user manager\n self.createappendcomp('usermanager', musermanager.MewloUserManager)\n\n # mail manager\n self.createappendcomp('mailmanager', mmailmanager.MewloMailManager)","def post_hook(self):\n self.mk_rg1()\n self.mk_rg2()\n self.mk_rg3()","def _create_directories(self):\n print \"[--init] creating directory structure in %s\" % (self.target_path)\n ensure_path(self.conf_path)\n for subdir in config.PROCESSING_AREAS:\n subdir_path = self.data_path + os.sep + subdir\n ensure_path(subdir_path)","def setup():\n for dir_path in [train_dir, output_dir]:\n Path(dir_path).mkdir(exist_ok=True)\n\n # create the training and test data files that we will use\n create_jsonlines_feature_files(train_dir)","def write_dependencies(self):\n\n references = self.tree.xpath('//ns:ProjectReference', namespaces=self.ns)\n if references:\n self.cmake.write('################### Dependencies ##################\\n'\n '# Add Dependencies to project. #\\n'\n '###################################################\\n\\n')\n self.cmake.write(\n 'option(BUILD_DEPENDS \\n' +\n ' \"Build other CMake project.\" \\n' +\n ' ON \\n' +\n ')\\n\\n'\n )\n self.cmake.write(\n '# Dependencies : disable BUILD_DEPENDS to link with lib already build.\\n'\n )\n if self.dependencies is None:\n self.cmake.write('if(BUILD_DEPENDS)\\n')\n for ref in references:\n reference = str(ref.get('Include'))\n path_to_reference = os.path.splitext(ntpath.basename(reference))[0]\n self.cmake.write(\n ' add_subdirectory(platform/cmake/%s ${CMAKE_BINARY_DIR}/%s)\\n' % (\n path_to_reference, path_to_reference\n )\n )\n else:\n self.cmake.write('if(BUILD_DEPENDS)\\n')\n d = 1\n for ref in self.dependencies:\n self.cmake.write(\n ' add_subdirectory(%s ${CMAKE_BINARY_DIR}/lib%s)\\n' % (ref, str(d)))\n send(\n 'Add manually dependencies : %s. Will be build in \"lib%s/\" !' % (\n ref, str(d)),\n 'warn'\n )\n d += 1\n self.cmake.write('else()\\n')\n for ref in references:\n reference = str(ref.get('Include'))\n path_to_reference = os.path.splitext(ntpath.basename(reference))[0]\n self.cmake.write(\n ' link_directories(dependencies/%s/build/)\\n' % path_to_reference\n )\n self.cmake.write('endif()\\n\\n')\n else: # pragma: no cover\n send('No link needed.', '')","def get_libraries(self):\r\n\r\n #### Begin functionality here\r\n if debug: eprint(\"INFO: Fetching all libraries\")\r\n session = self.session\r\n libraries = session.query(LibraryRecord).all()\r\n return(libraries)","def _add_jet_collection_and_dependencies(process, options, prefix, jet_algo_name, suffix, jet_kwargs):\n\n assert jet_algo_name in JET_COLLECTIONS, \"Unknown jet collection: {}\".format(jet_algo_name)\n\n _template_jet_collection_name = \"{}Jets{}\".format(prefix, jet_algo_name)\n _template_met_collection_name = \"{}METs{}\".format(prefix, jet_algo_name)\n _template_map_names = [\n \"{}Jet{}Map{}\".format(prefix, _obj_name, jet_algo_name)\n for _obj_name in ('TriggerObject', 'Muon', 'Electron')\n ]\n\n process.add_module(\n _template_jet_collection_name + suffix,\n getattr(process, _template_jet_collection_name).clone(\n **jet_kwargs\n )\n )\n process.add_module(\n _template_met_collection_name + suffix,\n getattr(process, _template_met_collection_name).clone(\n # jets for type-I correction\n karmaCorrectedJetCollectionSrc=cms.InputTag(\n _template_jet_collection_name + suffix\n ),\n )\n )\n\n for _template_map_name in _template_map_names:\n process.add_module(\n _template_map_name + suffix,\n getattr(process, _template_map_name).clone(\n primaryCollectionSrc=cms.InputTag(_template_jet_collection_name + suffix),\n )\n )\n\n if options.isData:\n # data-only\n\n # -- prefiring Weights\n _template_prefiring_weights_name = \"{}PrefiringWeights{}\".format(prefix, jet_algo_name)\n process.add_module(\n _template_prefiring_weights_name + suffix,\n getattr(process, _template_prefiring_weights_name).clone(\n karmaJetCollectionSrc = cms.InputTag(_template_jet_collection_name + suffix),\n )\n )\n else:\n # mc-only\n\n # -- jet-genjet maps\n _template_genjet_map_name = \"{}JetGenJetMap{}\".format(prefix, jet_algo_name)\n process.add_module(\n _template_genjet_map_name + suffix,\n getattr(process, _template_genjet_map_name).clone(\n primaryCollectionSrc=cms.InputTag(_template_jet_collection_name + suffix),\n secondaryCollectionSrc=cms.InputTag(\"karmaGenJets{}\".format(jet_algo_name[:3])),\n maxDeltaR=cms.double(0.4 if 'AK8' in jet_algo_name else 0.2)\n )\n )","def build_modules(self):\n self.backbone = Backbone(\n self.configs['backbone'],\n freeze_backbone=self.configs['freeze_backbone'],\n freeze_batchnorm=True\n )\n\n backbone_channel_sizes = get_backbone_channel_sizes(self.backbone)\n\n self.fpn = FeaturePyramidNetwork(\n backbone_channel_sizes=backbone_channel_sizes,\n min_feature_level=self.configs['min_feature_level'],\n max_feature_level=self.configs['max_feature_level'],\n feature_size=self.configs['pyramid_feature_size']\n )\n\n self.shared_conv_model = SharedConvModel(\n input_feature_size=self.configs['pyramid_feature_size'],\n feature_size=self.configs['shared_conv_feature_size'],\n num_layers=self.configs['shared_conv_num_layers']\n )\n\n if self.configs['shared_conv_num_layers'] > 0:\n shared_conv_output_size = self.configs['shared_conv_feature_size']\n else:\n shared_conv_output_size = self.configs['pyramid_feature_size']\n\n self.ofn = ObjectFinderNetwork(\n input_feature_size=shared_conv_output_size,\n feature_size=self.configs['finder_feature_size'],\n num_layers=self.configs['finder_num_layers']\n )\n\n self.ofn_loss_fn\n\n # self.classification_model = ClassificationModel()\n #\n # self.regression_model = RegressionModel()","def initialize(self):\n\n # create plugin locations\n for p in (cache_path, config_path, data_path):\n p.mkdir(parents=False, exist_ok=True)","def create_files(project_name, root_dir):\r\n root_dir = projectfolders.create_path(root_dir, project_name) #Modify the root\r\n \r\n write_setup(project_name, root_dir)\r\n write_inits(project_name, root_dir)\r\n write_tests(project_name, root_dir)","def _configure_libraries():\n # An environment option to disable `import cv2` globally,\n # in case it leads to negative performance impact\n disable_cv2 = int(os.environ.get(\"DETECTRON2_DISABLE_CV2\", False))\n if disable_cv2:\n sys.modules[\"cv2\"] = None\n else:\n # Disable opencl in opencv since its interaction with cuda often has negative effects\n # This envvar is supported after OpenCV 3.4.0\n os.environ[\"OPENCV_OPENCL_RUNTIME\"] = \"disabled\"\n try:\n import cv2\n\n if int(cv2.__version__.split(\".\")[0]) >= 3:\n cv2.ocl.setUseOpenCL(False)\n except ModuleNotFoundError:\n # Other types of ImportError, if happened, should not be ignored.\n # Because a failed opencv import could mess up address space\n # https://github.com/skvark/opencv-python/issues/381\n pass\n\n def get_version(module, digit=2):\n return tuple(map(int, module.__version__.split(\".\")[:digit]))\n\n # fmt: off\n assert get_version(torch) >= (1, 4), \"Requires torch>=1.4\"\n import fvcore\n assert get_version(fvcore, 3) >= (0, 1, 2), \"Requires fvcore>=0.1.2\"\n import yaml\n assert get_version(yaml) >= (5, 1), \"Requires pyyaml>=5.1\"\n # fmt: on"],"string":"[\n \"def createIntermediateLibraries(LISTPRELIBRARIES, DICOLIBRARIES, CONFIG, DICOFINALCLASSIF):\\n\\t#### Parse all the intermediate libraries files\\n\\tfor preLibrary in LISTPRELIBRARIES:\\n\\t\\t#### Retrieve the final classification name of the ET from the file name\\n\\t\\tfinalClassification = os.path.basename(preLibrary).split(\\\".fasta\\\")[0]\\n\\t\\t#### Read and store the fasta sequences of the prelibraries\\n\\t\\tsequences=readInput.readFasta(preLibrary)\\n\\t\\t#### Parse all the sequences\\n\\t\\tfor id in sequences:\\n\\t\\t\\t#### Check the finalClassification of the sequences is in the ID\\n\\t\\t\\tif finalClassification.lower() in id.lower():\\n\\t\\t\\t\\tDICOFINALCLASSIF[id]=finalClassification\\n\\t\\t\\t\\tapplyFiltersForIntermediate(id, sequences, finalClassification, CONFIG, DICOLIBRARIES)\",\n \"def makeLibrary(self):\\n #------------------------------------------ Instance for the output file\\n outputFile = open(\\\"%s/%s\\\" % (self.sceneryPath,self.libTxtFileName),\\\"w\\\")\\n #------------------------------------------------------ write the header\\n for line in self.header:\\n outputFile.write(\\\"%s\\\\n\\\" % (line))\\n #------------------------------------------------- Loop over all folders\\n packageContent = os.walk(self.sceneryPath)\\n for folder in packageContent:\\n for fileName in folder[2]:\\n fileType = fileName.split(\\\".\\\")[-1]\\n if fileType in self.objectTypes:\\n realPath = folder[0][len(self.sceneryPath)+1:].replace(\\\"\\\\\\\\\\\",\\\"/\\\")\\n filePath = \\\"%s/%s\\\" % (realPath,fileName)\\n print filePath\\n outputFile.write(\\\"EXPORT %s%s %s%s\\\\n\\\" % (self.libPrefix,filePath,self.realPathPrefix,filePath))\\n outputFile.close()\",\n \"def _shared_library_in_2steps(env):\\r\\n\\r\\n if not config.shared_library_1st in env['BUILDERS']:\\r\\n # The 1st builder\\r\\n shlinkcom_name = config.shared_library_1st + \\\"COM\\\"\\r\\n env[shlinkcom_name] = \\\"${TEMPFILE('$AR /DEF $ARFLAGS /OUT:$TARGET $SOURCES')}\\\"\\r\\n ar_action = SCons.Action.Action(\\\"$\\\" + shlinkcom_name, \\\"building '$TARGET' from '$SOURCE'\\\")\\r\\n emitter_name = config.shared_library_1st + \\\"EMITTER\\\"\\r\\n env[emitter_name] = [__lib_export_emitter]\\r\\n env[\\\"BUILDERS\\\"][config.shared_library_1st] = SCons.Builder.Builder(\\r\\n action=ar_action,\\r\\n emitter=\\\"$\\\" + emitter_name,\\r\\n prefix=\\\"$LIBPREFIX\\\",\\r\\n suffix=\\\"$LIBSUFFIX\\\",\\r\\n src_suffix=\\\"$SHOBJSUFFIX\\\",\\r\\n src_builder=\\\"SharedObject\\\")\\r\\n\\r\\n if not config.shared_library_2nd in env['BUILDERS']:\\r\\n # The 2nd builder\\r\\n emitter_name = config.shared_library_2nd + \\\"EMITTER\\\"\\r\\n env[emitter_name] = [__win32_lib_emitter]\\r\\n env[\\\"BUILDERS\\\"][config.shared_library_2nd] = SCons.Builder.Builder(\\r\\n action=[SCons.Defaults.SharedCheck,\\r\\n SCons.Action.Action(\\\"$SHLINKCOM\\\", \\\"building '$TARGET' from '$SOURCE'\\\")],\\r\\n emitter=\\\"$\\\" + emitter_name,\\r\\n prefix=\\\"$SHLIBPREFIX\\\",\\r\\n suffix=\\\"$SHLIBSUFFIX\\\",\\r\\n target_scanner=SCons.Scanner.Prog.ProgramScanner(),\\r\\n src_suffix=\\\"$SHOBJSUFFIX\\\",\\r\\n src_builder=\\\"SharedObject\\\")\",\n \"def library_dirs(self):\",\n \"def linking_library_dirs(self):\",\n \"def create_libs(desc: dict, pins: list, output_dir: str, verbose: bool = False):\\n db = desc.copy()\\n db[\\\"block_name\\\"] = desc[\\\"name_of_the_cell\\\"]\\n db[\\\"area\\\"] = db.pop(\\\"block_area_(um2)\\\")\\n db[\\\"pins\\\"] = pins\\n db[\\\"types\\\"] = [pin for pin in pins if pin.width > 1]\\n lib_paths = []\\n for corner, condition in desc.get(\\\"corners\\\", {}).items():\\n db[\\\"library\\\"] = \\\"%s_%s_%sV_%sC\\\" % (\\n desc.get(\\\"name_of_the_cell\\\"),\\n corner,\\n (\\\"%.2f\\\" % condition.get(\\\"voltage\\\")).replace('.', '_'),\\n str(condition.get(\\\"temperature\\\")).replace('-', 'm')\\n )\\n db[\\\"corner_name\\\"] = corner\\n db[\\\"corner\\\"] = condition\\n if verbose:\\n print(db)\\n # create directory if does not exist\\n os.makedirs(output_dir, exist_ok=True)\\n # generate lib file\\n template_file = os.path.join(os.path.dirname(__file__), \\\"./template_ana.lib.mako\\\")\\n _tmp = Template(filename=template_file)\\n lib_path = os.path.join(output_dir, \\\"%s.lib\\\" % db[\\\"library\\\"])\\n with open(lib_path, \\\"w+\\\") as fp:\\n fp.write(_tmp.render_unicode(**db))\\n lib_paths.append(lib_path)\\n return lib_paths\",\n \"def genLibData(self):\\n import mush\\n tsMain = string.Template(mush.libGenMain)\\n tsIfAltId = string.Template(mush.libGenIfAltId)\\n #--Data Records\\n for id in ('lib_action','lib_actionCount'):\\n glob = self.getRecord('GLOB',id,Glob)\\n (glob.type, glob.value) = ('s',0)\\n glob.setChanged()\\n setAllCode = 'begin lib_setAllGS\\\\n'\\n setNoneCode = 'begin lib_setNoneGS\\\\n'\\n for libId in self.libList:\\n (srcId,altId) = self.libMap[libId]\\n srcBook = self.srcBooks.get(srcId)[0]\\n if not srcBook:\\n print '%s: Missing source: %s' % (libId,srcId)\\n continue\\n #--Global\\n glob = self.getRecord('GLOB',libId+'G',Glob)\\n (glob.type, glob.value) = ('s',0)\\n glob.setChanged()\\n #--Script\\n scriptId = libId+'LS'\\n script = self.getRecord('SCPT',scriptId,Scpt)\\n scriptCode = tsMain.substitute(\\n libId=libId, srcId=srcId, ifAltId=(\\n (altId and tsIfAltId.substitute(libId=libId,altId=altId)) or ''))\\n script.setCode(scriptCode)\\n script.setChanged()\\n #--Book\\n srcBook.load(unpack=True)\\n book = self.getRecord('BOOK',libId,Book)\\n book.model = srcBook.model\\n book.title = srcBook.title\\n book.icon = srcBook.icon\\n book.text = srcBook.text\\n book.script = scriptId\\n book.setChanged()\\n #--Set Scripts\\n setAllCode += 'set %sG to 1\\\\n' % (libId,)\\n setNoneCode += 'set %sG to 0\\\\n' % (libId,)\\n #--Set scripts\\n for id,code in (('lib_setAllGS',setAllCode),('lib_setNoneGS',setNoneCode)):\\n code += ';--Done\\\\nstopScript %s\\\\nend\\\\n' % (id,)\\n script = self.getRecord('SCPT',id,Scpt)\\n script.setCode(code)\\n script.setChanged()\",\n \"def initialize_libraries(experiment, ln):\\n # Move into the folder to do the intial calculations in\\n folder = \\\"initial_library\\\" + str(ln)\\n os.chdir(folder) \\n # Create a time stamp for beginning the calculations\\n experiment[\\\"Summary\\\"] = \\\"Library \\\" + str(ln) + \\\" Initialization\\\\n\\\"\\n experiment[\\\"Summary\\\"] += \\\"Started\\\" + SHARING.time_stamp()\\n # Find the proper number of coordinates to consider\\n N = len(experiment[\\\"Movements\\\"][ln])/2\\n # Go through each antigen\\n for mol in experiment[0]:\\n # Apply the proper rotation\\n for cn in range(N):\\n # Create a generic vector of zeros of the appropriate length\\n vector = [0.0] * N\\n # Place a value of 1.0 in the correct location in the vector\\n vector[cn] = 1.0\\n # Find the angle to rotate the antigens by\\n angle = experiment[\\\"Movements\\\"][ln][N+cn]\\n # Rotate each of the antigens by the appropriate angle\\n rmatrix = MOLECULES.calculate_rmatrix(angle, vector)\\n MOLECULES.rotate(mol, rmatrix)\\n # Translate each antigen by the appropriate amount\\n MOLECULES.move(mol, experiment[\\\"Movements\\\"][ln][:N], '+')\\n # Update the reference folder with these updated coordinates\\n SHARING.output_Current(experiment, \\\"./Current/\\\") \\n # Load the canonical structures\\n canonicals = IPRO_FUNCTIONS.load_canonicals(experiment)\\n cdrs = list(canonicals.keys())\\n cdrs.sort()\\n # Load the clashes\\n clashes = IPRO_FUNCTIONS.load_clashes(experiment, cdrs) \\n # Load the C++ scores\\n raw_scores = IPRO_FUNCTIONS.load_scores(experiment[\\\"Folder\\\"])\\n # Look for alternate solutions using integer cuts\\n goOn = True\\n # Store the solutions in a list\\n solutions = [experiment[\\\"Scores\\\"][ln-1]]\\n # Keep searching for alternate solutions until the quality of the result is\\n # worse\\n while goOn:\\n # Resolve the MILP using integer cuts\\n if useCPLEX:\\n #solution = CPLEX.optcdr_canonicals(canonicals, clashes, \\\\\\n # raw_scores[ln], solutions)\\n pass\\n else:\\n solution = GAMS.optcdr_canonicals(canonicals, clashes, \\\\\\n raw_scores[ln], solutions)\\n # If the solution found has an equal objective value to the first, store\\n # it and re-run the MILP\\n if solution[\\\"Score\\\"] == experiment[\\\"Scores\\\"][ln-1][1][\\\"Score\\\"]:\\n solutions.append([experiment[\\\"Scores\\\"][ln-1][0], solution])\\n # Otherwise, break out of the loop and analyze the results\\n else:\\n goOn = False\\n # Update the library based on the most members for the cluster\\n best = 0\\n # Skip this if there is only one solution after applying the integer cuts\\n if len(solutions) > 1:\\n # Load the clusters\\n cdrs = list(canonicals.keys())\\n cdrs.sort()\\n clusters = load_clusters(experiment, cdrs)\\n # Initialize the variables to store the solution with the most cluster\\n # members\\n best = None\\n amount = 0\\n # Go through the solutions\\n for i, solution in enumerate(solutions):\\n # Store the total number of members throughout the CDRs\\n total = 0\\n # Go through the CDRs\\n for j, cdr in enumerate(cdrs):\\n # Extract the number of members from the \\\"clusters\\\" dictionary \\n members = clusters[cdr][solution[1][j+1]][\\\"Members\\\"]\\n # 30 is the number where the permitted amino acids change from\\n # \\\"of the same type\\\" to \\\"only those observed\\\" at each position\\n if members > 30:\\n members = 30\\n # Add the number of members to the total for this solution\\n total += members\\n # If applicable, update the \\\"best\\\" solution found and its\\n # corresponding total number of members\\n if total > amount:\\n best = i\\n amount = total\\n # Update the library based on the most structures\\n experiment[\\\"Scores\\\"][ln-1] = solutions[best]\\n # If the set of canonical structures has changed, update the referenced\\n # values\\n if best != 0:\\n SHARING.output_scores(experiment, experiment[\\\"Folder\\\"] + \\\"Current/\\\", ln)\\n # Copy the necessary files\\n SHARING.copy_standard_files(experiment, solv = True) \\n # Generate the antibody structures\\n build_antibodies(experiment, canonicals, ln) \\n # Go back to the home directory\\n os.chdir(\\\"../\\\")\\n # Try to create a new folder to handle the IPRO affinity maturation\\n folder = \\\"library\\\" + str(ln)\\n try:\\n os.mkdir(folder)\\n # If the folder already exists, delete it and make a new one. This is the\\n # proper procedure since the library should only be there if the\\n # initialization has already finished\\n except OSError:\\n os.system(\\\"rm -rf \\\" + folder)\\n os.mkdir(folder)\\n # Create a new Experiment class object to handle the IPRO affinity maturation\\n make_IPRO_experiment(experiment, folder)\\n # Delete the initialization folder\\n os.system(\\\"rm -rf initial_\\\" + folder) \\n # Update the summary file\\n # Create a summary file\\n experiment[\\\"Summary\\\"] += \\\"Ended\\\" + SHARING.time_stamp()\\n name = SHARING.summary_name(SHARING.get_current())\\n f = open(name, \\\"a\\\")\\n f.write(experiment[\\\"Summary\\\"])\\n f.close()\",\n \"def build_assets():\\n\\n # templates\\n template = open(os.path.join(BASE_PATH, 'AssetLibrary.as.template'), 'r').read()\\n\\n embed_templates = {\\n 'image': \\\"[Embed(source='%(asset_path)s')] private var %(asset_class_name)s:Class;\\\\n\\\",\\n 'mp3': \\\"[Embed(source='%(asset_path)s')] private var %(asset_class_name)s:Class;\\\\n\\\", \\n 'xml': \\\"[Embed(source='%(asset_path)s', mimeType=\\\\\\\"application/octet-stream\\\\\\\")] private var %(asset_class_name)s:Class;\\\\n\\\"\\n }\\n \\n library_element_template = \\\"'%(asset_id)s': %(asset_class_name)s\\\"\\n\\n # load+parse asset xml\\n complete_asset_embed_code = \\\"\\\"\\n complete_asset_data_code = \\\"\\\"\\n asset_dom = minidom.parse(ASSET_XML_FILE)\\n \\n asset_nodes = list(asset_dom.getElementsByTagName('asset'))\\n \\n for asset_node in asset_nodes:\\n asset_attrs = dict(asset_node.attributes.items())\\n asset_embed_code = embed_templates[asset_attrs['type']] % {\\n 'asset_class_name': asset_attrs['name'],\\n 'asset_path': ASSET_BASE + asset_attrs['file']\\n }\\n\\n complete_asset_embed_code += asset_embed_code\\n \\n asset_data_code = library_element_template % {\\n 'asset_id': asset_attrs['name'],\\n 'asset_class_name': asset_attrs['name']\\n }\\n\\n complete_asset_data_code += asset_data_code\\n\\n if asset_nodes.index(asset_node) == len(asset_nodes) - 1:\\n complete_asset_data_code += \\\"\\\\n\\\"\\n else:\\n complete_asset_data_code += \\\",\\\\n\\\"\\n \\n output = template % {\\n 'asset_embeds': complete_asset_embed_code,\\n 'asset_data': complete_asset_data_code\\n }\\n \\n # render\\n output_f = open(os.path.join(BASE_PATH, 'AssetLibrary.as'), 'w')\\n output_f.write(output)\",\n \"def test_project_with_dependencies(self):\\n self.make_project()\\n # 'test_library.zip' is not currently compiled for diorite.\\n self.project.app_platforms = \\\"aplite,basalt,chalk\\\"\\n self.project.save()\\n tempdir = tempfile.mkdtemp()\\n try:\\n # Extract a premade library to a temporary directory\\n ZipFile(LIBRARY_PATH).extractall(tempdir)\\n lib_path = os.path.join(tempdir, 'libname')\\n\\n # Include the library in the code and package.json\\n self.add_file(\\\"main.c\\\", DEPENDENCY_MAIN)\\n self.project.set_dependencies({\\n 'libname': lib_path\\n })\\n\\n # Compile and check\\n self.compile()\\n self.check_compile_success(num_platforms=3)\\n finally:\\n shutil.rmtree(tempdir)\",\n \"def make_productions3(self):\\n self.make_productions2()\\n for prod in self.make_productions_preterminals():\\n self.productions.add(prod)\",\n \"def save_libraries(self, a, lib):\\n logging.debug(\\\"in save libraries\\\")\\n self.libraries.append(lib)\\n self.produce(\\\"library\\\", lib)\",\n \"def _copy_bins():\\n # STEP 1: If we're performing a build from a copied source tree,\\n # copy the generated python files into the package\\n\\n _clean_bins()\\n\\n py_z3_build_dir = os.path.join(BUILD_DIR, 'python', 'z3')\\n root_z3_dir = os.path.join(ROOT_DIR, 'z3')\\n shutil.copy(os.path.join(py_z3_build_dir, 'z3core.py'), root_z3_dir)\\n shutil.copy(os.path.join(py_z3_build_dir, 'z3consts.py'), root_z3_dir)\\n\\n # STEP 2: Copy the shared library, the executable and the headers\\n\\n os.mkdir(LIBS_DIR)\\n os.mkdir(BINS_DIR)\\n os.mkdir(HEADERS_DIR)\\n shutil.copy(os.path.join(BUILD_DIR, LIBRARY_FILE), LIBS_DIR)\\n shutil.copy(os.path.join(BUILD_DIR, EXECUTABLE_FILE), BINS_DIR)\\n path1 = glob.glob(os.path.join(BUILD_DIR, \\\"msvcp*\\\"))\\n path2 = glob.glob(os.path.join(BUILD_DIR, \\\"vcomp*\\\"))\\n path3 = glob.glob(os.path.join(BUILD_DIR, \\\"vcrun*\\\"))\\n for filepath in path1 + path2 + path3:\\n shutil.copy(filepath, LIBS_DIR)\\n\\n for header_dir in HEADER_DIRS:\\n for fname in os.listdir(header_dir):\\n if not fname.endswith('.h'):\\n continue\\n shutil.copy(os.path.join(header_dir, fname), os.path.join(HEADERS_DIR, fname))\\n\\n # This hack lets z3 installed libs link on M1 macs; it is a hack, not a proper fix\\n # @TODO: Linked issue: https://github.com/Z3Prover/z3/issues/5926\\n major_minor = '.'.join(_z3_version().split('.')[:2])\\n link_name = None\\n if BUILD_PLATFORM in ('win32', 'cygwin', 'win'):\\n pass # TODO: When windows VMs work on M1, fill this in\\n elif BUILD_PLATFORM in ('darwin', 'osx'):\\n split = LIBRARY_FILE.split('.')\\n link_name = split[0] + '.' + major_minor + '.' + split[1]\\n else:\\n link_name = LIBRARY_FILE + '.' + major_minor\\n if link_name:\\n os.symlink(LIBRARY_FILE, os.path.join(LIBS_DIR, link_name), True)\",\n \"def add_library(self):\\n library = self.new_section('The Library')\\n books = self.wiki('the-library')._soup(class_='boxbook')\\n template = (\\n '<div class=\\\"book-title\\\">{}</div>'\\n '<div class=\\\"book-description\\\">{}</div>')\\n for b in books:\\n title = b.find(class_='booktitle').string\\n description = b.find(class_='boxleft')('div')[0].text.strip()\\n excerpts = [self.wiki.site + a['href']\\n for a in b.find(class_='boxright')('a')]\\n if title == 'The Journal of Aframos Longjourney':\\n links = self.wiki(excerpts[1])._soup.select('#page-content a')\\n links = [\\n 'http://wanderers-library.wikidot.com/' +\\n l['href'].split('/')[-1] for l in links]\\n excerpts = [excerpts[0]] + links\\n book = self.add_page(\\n title, template.format(title, description), library)\\n for url in excerpts:\\n self.add_url(url, book)\",\n \"def create_data_base():\\n\\n\\tscript_files = []\\n\\tjson_files = []\\n\\t\\n\\t# get script files list\\n\\tfor file in os.listdir(\\\"learned_objects_scripts/\\\"):\\n\\t\\tif file.endswith(\\\".script\\\"):\\n\\t\\t\\tscript_files.append(file)\\n\\n\\t# get json files list\\n\\tfor file in os.listdir(\\\"object_models/\\\"):\\n\\t\\tif file.endswith(\\\".json\\\"):\\n\\t\\t\\tjson_files.append(file)\\n\\t\\n\\t# create json file for new objects\\n\\tmodel_created = False\\n\\tfor file in script_files:\\n\\t\\tif \\\"{}.json\\\".format(file[:-7]) not in json_files:\\n\\t\\t\\twith open(\\\"object_models/{}.json\\\".format(file[:-7]), 'w') as outfile:\\n\\t\\t\\t\\tobj_model = object_script_to_model(\\\"learned_objects_scripts/\\\" + file)\\n\\t\\t\\t\\tjson.dump(obj_model, outfile)\\n\\t\\t\\t\\tmodel_created = True\\n\\t\\t\\t\\tprint(\\\"model created for\\\", file)\\n\\tif not model_created:\\n\\t\\tprint(\\\"data base is already up to date\\\")\",\n \"def gather() -> None:\\n # pylint: disable=too-many-locals\\n\\n # First off, clear out any existing output.\\n existing_dirs = [\\n os.path.join('src/external', d) for d in os.listdir('src/external')\\n if d.startswith('python-') and d != 'python-notes.txt'\\n ]\\n existing_dirs += [\\n os.path.join('assets/src', d) for d in os.listdir('assets/src')\\n if d.startswith('pylib-')\\n ]\\n for existing_dir in existing_dirs:\\n efrotools.run('rm -rf \\\"' + existing_dir + '\\\"')\\n\\n for buildtype in ['debug', 'release']:\\n debug = buildtype == 'debug'\\n bsuffix = '_debug' if buildtype == 'debug' else ''\\n bsuffix2 = '-debug' if buildtype == 'debug' else ''\\n\\n libname = 'python' + PYTHON_VERSION_MAJOR + ('dm' if debug else 'm')\\n\\n bases = {\\n 'mac':\\n f'build/python_apple_mac{bsuffix}/build/macOS',\\n 'ios':\\n f'build/python_apple_ios{bsuffix}/build/iOS',\\n 'tvos':\\n f'build/python_apple_tvos{bsuffix}/build/tvOS',\\n 'android_arm':\\n f'build/python_android_arm{bsuffix}/build/sysroot',\\n 'android_arm64':\\n f'build/python_android_arm64{bsuffix}/build/sysroot',\\n 'android_x86':\\n f'build/python_android_x86{bsuffix}/build/sysroot',\\n 'android_x86_64':\\n f'build/python_android_x86_64{bsuffix}/build/sysroot'\\n }\\n\\n # Note: only need pylib for the first in each group.\\n builds: List[Dict[str, Any]] = [{\\n 'name':\\n 'macos',\\n 'group':\\n 'apple',\\n 'headers':\\n bases['mac'] + '/Support/Python/Headers',\\n 'libs': [\\n bases['mac'] + '/Support/Python/libPython.a',\\n bases['mac'] + '/Support/OpenSSL/libOpenSSL.a',\\n bases['mac'] + '/Support/XZ/libxz.a'\\n ],\\n 'pylib':\\n (bases['mac'] + '/python/lib/python' + PYTHON_VERSION_MAJOR),\\n }, {\\n 'name':\\n 'ios',\\n 'group':\\n 'apple',\\n 'headers':\\n bases['ios'] + '/Support/Python/Headers',\\n 'libs': [\\n bases['ios'] + '/Support/Python/libPython.a',\\n bases['ios'] + '/Support/OpenSSL/libOpenSSL.a',\\n bases['ios'] + '/Support/XZ/libxz.a'\\n ],\\n }, {\\n 'name':\\n 'tvos',\\n 'group':\\n 'apple',\\n 'headers':\\n bases['tvos'] + '/Support/Python/Headers',\\n 'libs': [\\n bases['tvos'] + '/Support/Python/libPython.a',\\n bases['tvos'] + '/Support/OpenSSL/libOpenSSL.a',\\n bases['tvos'] + '/Support/XZ/libxz.a'\\n ],\\n }, {\\n 'name':\\n 'android_arm',\\n 'group':\\n 'android',\\n 'headers':\\n bases['android_arm'] + f'/usr/include/{libname}',\\n 'libs': [\\n bases['android_arm'] + f'/usr/lib/lib{libname}.a',\\n bases['android_arm'] + '/usr/lib/libssl.a',\\n bases['android_arm'] + '/usr/lib/libcrypto.a',\\n bases['android_arm'] + '/usr/lib/liblzma.a',\\n bases['android_arm'] + '/usr/lib/libsqlite3.a'\\n ],\\n 'libinst':\\n 'android_armeabi-v7a',\\n 'pylib': (bases['android_arm'] + '/usr/lib/python' +\\n PYTHON_VERSION_MAJOR),\\n }, {\\n 'name': 'android_arm64',\\n 'group': 'android',\\n 'headers': bases['android_arm64'] + f'/usr/include/{libname}',\\n 'libs': [\\n bases['android_arm64'] + f'/usr/lib/lib{libname}.a',\\n bases['android_arm64'] + '/usr/lib/libssl.a',\\n bases['android_arm64'] + '/usr/lib/libcrypto.a',\\n bases['android_arm64'] + '/usr/lib/liblzma.a',\\n bases['android_arm64'] + '/usr/lib/libsqlite3.a'\\n ],\\n 'libinst': 'android_arm64-v8a',\\n }, {\\n 'name': 'android_x86',\\n 'group': 'android',\\n 'headers': bases['android_x86'] + f'/usr/include/{libname}',\\n 'libs': [\\n bases['android_x86'] + f'/usr/lib/lib{libname}.a',\\n bases['android_x86'] + '/usr/lib/libssl.a',\\n bases['android_x86'] + '/usr/lib/libcrypto.a',\\n bases['android_x86'] + '/usr/lib/liblzma.a',\\n bases['android_x86'] + '/usr/lib/libsqlite3.a'\\n ],\\n 'libinst': 'android_x86',\\n }, {\\n 'name': 'android_x86_64',\\n 'group': 'android',\\n 'headers': bases['android_x86_64'] + f'/usr/include/{libname}',\\n 'libs': [\\n bases['android_x86_64'] + f'/usr/lib/lib{libname}.a',\\n bases['android_x86_64'] + '/usr/lib/libssl.a',\\n bases['android_x86_64'] + '/usr/lib/libcrypto.a',\\n bases['android_x86_64'] + '/usr/lib/liblzma.a',\\n bases['android_x86_64'] + '/usr/lib/libsqlite3.a'\\n ],\\n 'libinst': 'android_x86_64',\\n }]\\n\\n for build in builds:\\n\\n grp = build['group']\\n builddir = f'src/external/python-{grp}{bsuffix2}'\\n header_dst = os.path.join(builddir, 'include')\\n lib_dst = os.path.join(builddir, 'lib')\\n assets_src_dst = f'assets/src/pylib-{grp}'\\n\\n # Do some setup only once per group.\\n if not os.path.exists(builddir):\\n efrotools.run('mkdir -p \\\"' + builddir + '\\\"')\\n efrotools.run('mkdir -p \\\"' + lib_dst + '\\\"')\\n\\n # Only pull modules into game assets on release pass.\\n if not debug:\\n # Copy system modules into the src assets\\n # dir for this group.\\n efrotools.run('mkdir -p \\\"' + assets_src_dst + '\\\"')\\n efrotools.run(\\n 'rsync --recursive --include \\\"*.py\\\"'\\n ' --exclude __pycache__ --include \\\"*/\\\" --exclude \\\"*\\\" \\\"'\\n + build['pylib'] + '/\\\" \\\"' + assets_src_dst + '\\\"')\\n\\n # Prune a bunch of modules we don't need to cut\\n # down on size.\\n prune = [\\n 'config-*', 'idlelib', 'lib-dynload', 'lib2to3',\\n 'multiprocessing', 'pydoc_data', 'site-packages',\\n 'ensurepip', 'tkinter', 'wsgiref', 'distutils',\\n 'turtle.py', 'turtledemo', 'test', 'sqlite3/test',\\n 'unittest', 'dbm', 'venv', 'ctypes/test', 'imaplib.py',\\n '_sysconfigdata_*'\\n ]\\n efrotools.run('cd \\\"' + assets_src_dst + '\\\" && rm -rf ' +\\n ' '.join(prune))\\n\\n # Some minor filtering to system scripts:\\n # on iOS/tvOS, addusersitepackages() leads to a crash\\n # due to _sysconfigdata_dm_ios_darwin module not existing,\\n # so let's skip that.\\n fname = f'{assets_src_dst}/site.py'\\n txt = efrotools.readfile(fname)\\n txt = efrotools.replace_one(\\n txt,\\n ' known_paths = addusersitepackages(known_paths)',\\n ' # efro tweak: this craps out on ios/tvos.\\\\n'\\n ' # (and we don\\\\'t use it anyway)\\\\n'\\n ' # known_paths = addusersitepackages(known_paths)')\\n efrotools.writefile(fname, txt)\\n\\n # Copy in a base set of headers (everything in a group should\\n # be using the same headers)\\n efrotools.run(f'cp -r \\\"{build[\\\"headers\\\"]}\\\" \\\"{header_dst}\\\"')\\n\\n # Clear whatever pyconfigs came across; we'll build our own\\n # universal one below.\\n efrotools.run('rm ' + header_dst + '/pyconfig*')\\n\\n # Write a master pyconfig header that reroutes to each\\n # platform's actual header.\\n with open(header_dst + '/pyconfig.h', 'w') as hfile:\\n hfile.write(\\n '#if BA_OSTYPE_MACOS\\\\n'\\n '#include \\\"pyconfig-macos.h\\\"\\\\n\\\\n'\\n '#elif BA_OSTYPE_IOS\\\\n'\\n '#include \\\"pyconfig-ios.h\\\"\\\\n\\\\n'\\n '#elif BA_OSTYPE_TVOS\\\\n'\\n '#include \\\"pyconfig-tvos.h\\\"\\\\n\\\\n'\\n '#elif BA_OSTYPE_ANDROID and defined(__arm__)\\\\n'\\n '#include \\\"pyconfig-android_arm.h\\\"\\\\n\\\\n'\\n '#elif BA_OSTYPE_ANDROID and defined(__aarch64__)\\\\n'\\n '#include \\\"pyconfig-android_arm64.h\\\"\\\\n\\\\n'\\n '#elif BA_OSTYPE_ANDROID and defined(__i386__)\\\\n'\\n '#include \\\"pyconfig-android_x86.h\\\"\\\\n\\\\n'\\n '#elif BA_OSTYPE_ANDROID and defined(__x86_64__)\\\\n'\\n '#include \\\"pyconfig-android_x86_64.h\\\"\\\\n\\\\n'\\n '#else\\\\n'\\n '#error unknown platform\\\\n\\\\n'\\n '#endif\\\\n')\\n\\n # Now copy each build's config headers in with unique names.\\n cfgs = [\\n f for f in os.listdir(build['headers'])\\n if f.startswith('pyconfig')\\n ]\\n\\n # Copy config headers to their filtered names.\\n for cfg in cfgs:\\n out = cfg.replace('pyconfig', 'pyconfig-' + build['name'])\\n if cfg == 'pyconfig.h':\\n\\n # For platform's root pyconfig.h we need to filter\\n # contents too (those headers can themselves include\\n # others; ios for instance points to a arm64 and a\\n # x86_64 variant).\\n contents = efrotools.readfile(build['headers'] + '/' + cfg)\\n contents = contents.replace('pyconfig',\\n 'pyconfig-' + build['name'])\\n efrotools.writefile(header_dst + '/' + out, contents)\\n else:\\n # other configs we just rename\\n efrotools.run('cp \\\"' + build['headers'] + '/' + cfg +\\n '\\\" \\\"' + header_dst + '/' + out + '\\\"')\\n\\n # Copy in libs. If the lib gave a specific install name,\\n # use that; otherwise use name.\\n targetdir = lib_dst + '/' + build.get('libinst', build['name'])\\n efrotools.run('rm -rf \\\"' + targetdir + '\\\"')\\n efrotools.run('mkdir -p \\\"' + targetdir + '\\\"')\\n for lib in build['libs']:\\n efrotools.run('cp \\\"' + lib + '\\\" \\\"' + targetdir + '\\\"')\\n\\n print('Great success!')\",\n \"def test_index_libraries(self):\\n result1 = self._create_library(slug=\\\"test-lib-index-1\\\", title=\\\"Title 1\\\", description=\\\"Description\\\")\\n result2 = self._create_library(slug=\\\"test-lib-index-2\\\", title=\\\"Title 2\\\", description=\\\"Description\\\")\\n\\n for result in [result1, result2]:\\n library_key = LibraryLocatorV2.from_string(result['id'])\\n response = ContentLibraryIndexer.get_items([library_key])[0]\\n\\n assert response['id'] == result['id']\\n assert response['title'] == result['title']\\n assert response['description'] == result['description']\\n assert response['uuid'] == result['bundle_uuid']\\n assert response['num_blocks'] == 0\\n assert response['version'] == result['version']\\n assert response['last_published'] is None\\n assert response['has_unpublished_changes'] is False\\n assert response['has_unpublished_deletes'] is False\",\n \"def makeProjects(self, *versions):\\n baseDirectory = FilePath(self.mktemp())\\n baseDirectory.createDirectory()\\n for version in versions:\\n self.makeProject(version, baseDirectory)\\n return baseDirectory\",\n \"def create_init_files(self, app_label, model_names, models):\\n model_name_slugs = [\\\"%s_views\\\" % (self.camel_to_slug(model_name)) for model_name in model_names]\\n model_names_dict = {self.camel_to_slug(model.__name__): self.camel_to_slug(self.model_name_plural(model)) for\\n model in models}\\n for folder_name in [\\\"views\\\", \\\"urls\\\"]:\\n file_path = \\\"%s/%s/__init__.py\\\" % (app_label, folder_name)\\n template_path = \\\"django_baker/__init__%s\\\" % folder_name\\n self.create_file_from_template(file_path, template_path, {\\\"app_label\\\": app_label,\\n \\\"model_name_slugs\\\": model_name_slugs,\\n \\\"model_names_dict\\\": model_names_dict\\n })\",\n \"def mk_rg3(self):\\n pass\",\n \"def main():\\n # Create / clean output dir\\n if os.path.isdir(OUT_DIR):\\n shutil.rmtree(OUT_DIR)\\n os.mkdir(OUT_DIR)\\n\\n # Write all assets to the directory\\n for fname, bb in create_assets().items():\\n filename = os.path.join(OUT_DIR, fname)\\n dirname = os.path.dirname(filename)\\n if not os.path.isdir(dirname):\\n os.makedirs(dirname)\\n with open(filename, \\\"wb\\\") as f:\\n f.write(bb)\",\n \"def __init__(self):\\n self._ll = LowLevelLibs()\\n self._lib = self._ll.phe\",\n \"def __init__(self, lib_dir, dist_dir, windows_exe_files=[],\\n console_exe_files=[], service_exe_files=[],\\n comserver_files=[], lib_files=[]):\\n self.lib_dir = lib_dir\\n self.dist_dir = dist_dir\\n if not self.dist_dir[-1] in \\\"\\\\\\\\/\\\":\\n self.dist_dir += \\\"\\\\\\\\\\\"\\n self.name = AppName\\n self.lname = AppName.lower()\\n self.version = AppVersion\\n self.windows_exe_files = [self.chop(p) for p in windows_exe_files]\\n self.console_exe_files = [self.chop(p) for p in console_exe_files]\\n self.service_exe_files = [self.chop(p) for p in service_exe_files]\\n self.comserver_files = [self.chop(p) for p in comserver_files]\\n self.lib_files = [self.chop(p) for p in lib_files]\\n self.icon = os.path.abspath(r'doc\\\\icon\\\\favicon.ico')\",\n \"def _setup(self):\\n mkdir_p(self.output_folder)\\n if self.symlink_dir:\\n mkdir_p(self.symlink_dir)\\n try:\\n selected_versions = self._resolve_dependencies()\\n if selected_versions:\\n self._write_lock(selected_versions)\\n print('\\\\n\\\\nVersions Selected for downloading:\\\\n')\\n print('\\\\t' + '\\\\n\\\\t'.join(['{}: {}'.format(req, ver) for req, ver in selected_versions.items()]) + '\\\\n')\\n for pkg_name, version in selected_versions.items():\\n pkg_metadata = self._get_metadata(pkg_name)\\n version_metadata = pkg_metadata.get('versions', dict()).get(str(version), dict())\\n self._download_package(version_metadata)\\n except (RequirementMatchError, DependencyError) as e:\\n print(e.message)\\n return self.created()\",\n \"def get_libraries(self, archs: list[str]):\\n libraries = self.ScopedLibraryDict.get(\\\"common\\\", []).copy()\\n\\n for arch in archs:\\n libraries + self.ScopedLibraryDict.get(arch, []).copy()\\n return list(set(libraries))\",\n \"def makeProjects(self, *versions):\\n baseDirectory = FilePath(self.mktemp())\\n for version in versions:\\n self.makeProject(version, baseDirectory)\\n return baseDirectory\",\n \"def create_aiida_project_environment(self):\\n try:\\n self.create_folder_structure()\\n self.build_python_environment()\\n self.install_packages_from_index()\\n except Exception:\\n self.exit_on_exception()\\n raise\\n self.create_spec_entry()\",\n \"def create_packages(self):\\n if not self.rewrite:\\n # The extra package structure is only required for vendored code used via import rewrites.\\n return\\n\\n for index, _ in enumerate(self._subpath_components):\\n relpath = _PACKAGE_COMPONENTS + self._subpath_components[: index + 1] + [\\\"__init__.py\\\"]\\n touch(os.path.join(self.ROOT, *relpath))\",\n \"def setup_lib(CLIB):\\n # {{ SETUP_LIB }}\",\n \"def gen_library(self):\\n newlibrary = self.newlibrary\\n whelpers.add_all_helpers(newlibrary.symtab)\\n\\n self.function_index = newlibrary.function_index\\n self.class_map = newlibrary.class_map\\n\\n self.instantiate_all_classes(newlibrary.wrap_namespace)\\n self.update_templated_typemaps(newlibrary.wrap_namespace)\\n self.gen_namespace(newlibrary.wrap_namespace)\",\n \"def create_main_dir(self):\\n\\n set_of_dirs= [ self.root_laas_ws,\\n self.root_laas_ws+'/src',\\n self.root_laas_ws+'/install']\\n \\n # Creates set_of_dirs if they do not exist\\n for a_dir in list_of_dirs:\\n if not os.path(a_dir).is_dir():\\n os.makedirs(a_dir,0o777,True)\",\n \"def init():\\n run('mkdir -p %(releases_dir)s' % env)\\n execute(cleanup)\\n execute(create_directories)\",\n \"def shared_temporal_libraries(self):\\n foo='shared_temporal_libraries () {\\\\n'\\n foo+='#bring or delete necessary temporary libraries\\\\n'\\n foo+=' e=1\\\\n' #initialize exit status as error\\n if self.shared:\\n cmd=sharedexe+' -a \\\"'+self.shared+'\\\" -b $$ -c $1' #$1== _PREPARE_ or _CLEANUP_\\n foo+=' if '+cmd+'; then e=0;fi\\\\n'\\n else:\\n foo+=' echo \\\"no shared temporal libraries to $1\\\" && e=0\\\\n'\\n foo+=' return $e\\\\n'\\n foo+='}'\\n return foo\",\n \"def link_dependencies(self):\\n\\n # External libraries\\n references = self.tree.xpath('//ns:ProjectReference', namespaces=self.ns)\\n if references:\\n self.cmake.write('# Link with other dependencies.\\\\n')\\n self.cmake.write('target_link_libraries(${PROJECT_NAME} ')\\n for ref in references:\\n reference = str(ref.get('Include'))\\n path_to_reference = os.path.splitext(ntpath.basename(reference))[0]\\n lib = os.path.splitext(ntpath.basename(reference))[0]\\n if lib == 'g3log':\\n lib += 'ger' # To get \\\"g3logger\\\"\\n self.cmake.write(lib + ' ')\\n message = 'External library found : %s' % path_to_reference\\n send(message, '')\\n self.cmake.write(')\\\\n')\\n\\n # Additional Dependencies\\n dependencies = self.tree.xpath('//ns:AdditionalDependencies', namespaces=self.ns)\\n if dependencies:\\n listdepends = dependencies[0].text.replace('%(AdditionalDependencies)', '')\\n if listdepends != '':\\n send('Additional Dependencies = %s' % listdepends, 'ok')\\n windepends = []\\n for d in listdepends.split(';'):\\n if d != '%(AdditionalDependencies)':\\n if os.path.splitext(d)[1] == '.lib':\\n windepends.append(d)\\n if windepends:\\n self.cmake.write('if(MSVC)\\\\n')\\n self.cmake.write(' target_link_libraries(${PROJECT_NAME} ')\\n for dep in windepends:\\n self.cmake.write(dep + ' ')\\n self.cmake.write(')\\\\n')\\n self.cmake.write('endif(MSVC)\\\\n')\\n else: # pragma: no cover\\n send('No dependencies.', '')\",\n \"def __init__(self):\\n self._ll = LowLevelLibs()\\n self._lib = self._ll.pythia\",\n \"def make_libfile():\\n # wfc3_obsmodes_uvis\\n wfc3_uvis = [\\n \\\"f218w\\\",\\n \\\"f225w\\\",\\n \\\"f275w\\\",\\n \\\"f336w\\\",\\n \\\"f390m\\\",\\n \\\"f390w\\\",\\n \\\"f410m\\\",\\n \\\"f438w\\\",\\n \\\"f467m\\\",\\n \\\"f475w\\\",\\n \\\"f547m\\\",\\n \\\"f555w\\\",\\n \\\"f606w\\\",\\n \\\"f621m\\\",\\n \\\"f625w\\\",\\n \\\"f689m\\\",\\n \\\"f763m\\\",\\n \\\"f775w\\\",\\n \\\"f814w\\\",\\n \\\"f845m\\\",\\n ]\\n\\n wfc3_ir = [\\n \\\"f098m\\\",\\n \\\"f105w\\\",\\n \\\"f110w\\\",\\n \\\"f125w\\\",\\n \\\"f127m\\\",\\n \\\"f139m\\\",\\n \\\"f140w\\\",\\n \\\"f153m\\\",\\n \\\"f160w\\\",\\n ]\\n\\n wfpc2 = [\\n \\\"f122m\\\",\\n \\\"f157w\\\",\\n \\\"f336w\\\",\\n \\\"f410m\\\",\\n \\\"f467m\\\",\\n \\\"f547m\\\",\\n \\\"f439w\\\",\\n \\\"f569w\\\",\\n \\\"f675w\\\",\\n \\\"f791w\\\",\\n \\\"f170w\\\",\\n \\\"f185w\\\",\\n \\\"f218w\\\",\\n \\\"f255w\\\",\\n \\\"f300w\\\",\\n \\\"f380w\\\",\\n \\\"f555w\\\",\\n \\\"f622w\\\",\\n \\\"f450w\\\",\\n \\\"f606w\\\",\\n \\\"f702w\\\",\\n \\\"f814w\\\",\\n ]\\n\\n acs_wfc = [\\n \\\"f435w\\\",\\n \\\"f475w\\\",\\n \\\"f550m\\\",\\n \\\"f555w\\\",\\n \\\"f606w\\\",\\n \\\"f625w\\\",\\n \\\"f775w\\\",\\n \\\"f814w\\\",\\n ]\\n # galex\\n galex = [\\\"fuv\\\", \\\"nuv\\\"]\\n\\n # Open hd5 file for writing\\n hf = h5py.File(__ROOT__ + \\\"filters.hd5\\\", \\\"w\\\")\\n\\n # Create group for nice hierarchical structure\\n f = hf.create_group(\\\"filters\\\")\\n\\n # Define arrays for \\\"contents\\\" / descriptive information\\n tablenames = []\\n observatories = []\\n instruments = []\\n names = []\\n norms = []\\n cwaves = []\\n pwaves = []\\n comments = []\\n\\n # Loop through WFC3_UVIS filters\\n for filt in wfc3_uvis:\\n\\n # define uvis 1 and uvis2 modes\\n mode_1 = \\\"wfc3, uvis1, \\\" + filt\\n mode_2 = \\\"wfc3, uvis2, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_WFC3_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFC3\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of uvis1 and uvis2\\\")\\n\\n # Loop through WFC3_IR filters\\n for filt in wfc3_ir:\\n\\n # define ir mode\\n mode = \\\"wfc3, ir, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp = stsyn.band(mode)\\n\\n # extract the wavelength array\\n wave = bp.waveset\\n\\n # define the filter name\\n filter_name = \\\"HST_WFC3_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFC3\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"\\\")\\n\\n # Loop through WFPC2 filters\\n for filt in wfpc2:\\n\\n # define chips 1, 2, 3, 4 modes\\n mode_1 = \\\"wfpc2, 1, \\\" + filt\\n mode_2 = \\\"wfpc2, 2, \\\" + filt\\n mode_3 = \\\"wfpc2, 3, \\\" + filt\\n mode_4 = \\\"wfpc2, 4, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n bp_3 = stsyn.band(mode_3)\\n bp_4 = stsyn.band(mode_4)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave), bp_3(wave), bp_4(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_WFPC2_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"WFPC2\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of 1, 2, 3, 4\\\")\\n\\n # Loop through ACS filters\\n for filt in acs_wfc:\\n\\n # define wfc1, wfc2 modes\\n mode_1 = \\\"acs, wfc1, \\\" + filt\\n mode_2 = \\\"acs, wfc2, \\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp_1 = stsyn.band(mode_1)\\n bp_2 = stsyn.band(mode_2)\\n\\n # extract the wavelength array\\n wave = bp_1.waveset\\n\\n # compute the average bandpass between uvis1 and uvis2\\n bp_avg = np.average([bp_1(wave), bp_2(wave)], axis=0)\\n\\n # define the filter name\\n filter_name = \\\"HST_ACS_WFC_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp_avg.astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp_avg, name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"HST\\\")\\n instruments.append(\\\"ACS_WFC\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"avg of wfc1 and wfc2\\\")\\n\\n # Loop through GALEX filters:\\n for filt in galex:\\n # define ir mode\\n mode = \\\"galex,\\\" + filt\\n\\n # pull bandpasses from stsynphot for the two uvis modes\\n bp = stsyn.band(mode)\\n\\n # extract the wavelength array\\n wave = bp.waveset\\n\\n # define the filter name\\n filter_name = \\\"GALEX_\\\" + filt.upper()\\n\\n # build array of wavelength and throughput\\n arr = np.array(\\n list(zip(wave.value.astype(np.float64), bp(wave).astype(np.float64))),\\n dtype=[(\\\"WAVELENGTH\\\", \\\"float64\\\"), (\\\"THROUGHPUT\\\", \\\"float64\\\")],\\n )\\n\\n # append dataset to the hdf5 filters group\\n f.create_dataset(filter_name, data=arr)\\n\\n # generate filter instance to compute relevant info\\n newfilt = phot.Filter(wave, bp(wave), name=filt.upper())\\n\\n # populate contents lists with relevant information\\n tablenames.append(filter_name)\\n observatories.append(\\\"GALEX\\\")\\n instruments.append(\\\"GALEX\\\")\\n names.append(newfilt.name)\\n norms.append(newfilt.norm.value)\\n cwaves.append(newfilt.cl.value)\\n pwaves.append(newfilt.lpivot.value)\\n comments.append(\\\"\\\")\\n\\n # smash the contents arrays together\\n contents = np.array(\\n list(\\n zip(\\n tablenames,\\n observatories,\\n instruments,\\n names,\\n norms,\\n cwaves,\\n pwaves,\\n comments,\\n )\\n ),\\n dtype=[\\n (\\\"TABLENAME\\\", \\\"S40\\\"),\\n (\\\"OBSERVATORY\\\", \\\"S30\\\"),\\n (\\\"INSTRUMENT\\\", \\\"S30\\\"),\\n (\\\"NAME\\\", \\\"S10\\\"),\\n (\\\"NORM\\\", \\\"<f8\\\"),\\n (\\\"CWAVE\\\", \\\"<f8\\\"),\\n (\\\"PWAVE\\\", \\\"<f8\\\"),\\n (\\\"COMMENT\\\", \\\"S100\\\"),\\n ],\\n )\\n\\n # add the contents array as an hd5 dataset\\n hf.create_dataset(\\\"content\\\", data=contents)\\n\\n # close the file\\n hf.close()\",\n \"def build_all(self):\\n self.android_build()\\n self.generate_patch_build('')\\n self.generate_specs_build()\\n self.generate_interfaces()\",\n \"def init(cx):\\n\\n\\n # create the folder structure\\n for d in PROJECT_DIRS:\\n cx.run(\\\"mkdir -p {}\\\".format(d))\\n cx.run(\\\"touch {}/.keep\\\".format(d))\",\n \"def init(self):\\n # Create the default project files\\n self.create_from_templates()\\n\\n # Add all the newly created files to the git staging area\\n self.add_all_untracked()\\n\\n # Check that a compatible version of Python is available; install it if not\\n self._pyenv.ensure_python(self.get_python_version())\\n\\n # Create virtualenv\\n self._pyenv.create_virtualenv(self.name, self.get_python_version())\",\n \"def _setup(self):\\n self._raw_top_dir = os.path.join(self._snippets_dir,\\\"raw\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._raw_top_dir):\\n os.mkdir(self._raw_top_dir)\\n\\n self._trec_top_dir = os.path.join(self._snippets_dir,\\\"trec\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._trec_top_dir):\\n os.mkdir(self._trec_top_dir)\\n\\n self._temp_top_dir = os.path.join(self._snippets_dir,\\\"temp\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._temp_top_dir):\\n os.mkdir(self._temp_top_dir)\\n\\n self._snippet_result_top_dir = os.path.join(self._snippets_dir,\\\"result\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._snippet_result_top_dir):\\n os.mkdir(self._snippet_result_top_dir)\\n\\n self._snippet_index_top_dir = os.path.join(self._snippets_dir,\\\"index\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._snippet_index_top_dir):\\n os.mkdir(self._snippet_index_top_dir)\\n\\n self._para_top_dir = os.path.join(self._snippets_dir,\\\"para\\\",\\\"dynamic\\\")\\n if not os.path.exists(self._para_top_dir):\\n os.mkdir(self._para_top_dir)\",\n \"def add_lib(ctx, sources, library, folder, roles, lib_desc, lib_synopsis, datatype, no_file_check, replace, no_biomaj_env):\\n\\n if not sources:\\n print(\\\"Nothing to do\\\")\\n return\\n\\n if not library:\\n if 'dbname' in os.environ:\\n library = os.environ['dbname']\\n else:\\n raise Exception('No library defined. Use the --library option.')\\n\\n sources = check_input(sources, check_existence=(not no_file_check), use_biomaj_env=(not no_biomaj_env))\\n\\n r_roles = []\\n if roles:\\n print(\\\"Checking roles\\\")\\n roles = roles.split(',')\\n r_roles = get_roles(ctx.gi, roles)\\n\\n print(\\\"Adding to data library '\\\" + str(library) + \\\"'\\\")\\n\\n if not folder:\\n folder = '/'\\n dest = os.path.normpath(folder)\\n dest = dest.split(os.sep)\\n dest = [x for x in dest if x] # Remove empty string when sep at the begin or end, or multiple sep\\n\\n found_lib = get_library(ctx.gi, library, lib_desc, lib_synopsis)\\n\\n print(\\\"Preparing folders in library '\\\" + library + \\\"'\\\")\\n\\n dest_folder = create_tree(ctx.gi, found_lib, dest)\\n\\n check_existing(ctx.gi, found_lib, dest, sources, replace)\\n\\n print(\\\"Adding \\\" + str(len(sources)) + \\\" file(s) to the library '\\\" + library + \\\"'\\\")\\n add_files(ctx.gi, found_lib, dest_folder, sources, r_roles, datatype)\\n\\n print(\\\"Done!\\\")\",\n \"def create_library(self, org, library, user_id, fields, **kwargs):\\n kwargs[\\\"fields\\\"] = fields\\n kwargs[\\\"master_branch\\\"] = kwargs.get(\\\"master_branch\\\", ModuleStoreEnum.BranchName.library)\\n kwargs[\\\"root_category\\\"] = kwargs.get(\\\"root_category\\\", \\\"library\\\")\\n kwargs[\\\"root_block_id\\\"] = kwargs.get(\\\"root_block_id\\\", \\\"library\\\")\\n locator = LibraryLocator(org=org, library=library, branch=kwargs[\\\"master_branch\\\"])\\n return self._create_courselike(locator, user_id, **kwargs)\",\n \"def run(self):\\n self._make_lib_file_symbolic_links()\\n self._copy_each_include_files_to_include_dir()\\n self._make_dep_lib_file_sym_links_and_copy_include_files()\\n self.setup_py.add_patchs_to_build_without_pkg_config(\\n self.rpm.lib_dir, self.rpm.include_dir\\n )\\n self.setup_py.apply_and_save()\\n self._build_and_install()\",\n \"def __init__(self):\\n self._ll = LowLevelLibs()\\n self._lib = self._ll.foundation\",\n \"def build(request):\\n \\n def get(name):\\n return request.GET.get(name)\\n def get_arr(name):\\n val = get(name)\\n if val:\\n return val.split(\\\",\\\")\\n else:\\n return []\\n\\n require = get_arr(\\\"require\\\")\\n exclude = get_arr(\\\"exclude\\\")\\n excludeLibs = get_arr(\\\"excludeLibs\\\")\\n requireLibs = get_arr(\\\"requireLibs\\\")\\n download = get(\\\"download\\\")\\n reset = get(\\\"reset\\\")\\n client = get(\\\"client\\\")\\n compression = get(\\\"compression\\\")\\n\\n dpdr = None\\n global depender\\n if settings.DEPENDER_DEBUG:\\n dpdr = make_depender()\\n else:\\n dpdr = depender\\n if reset == \\\"true\\\":\\n depender = dpdr\\n \\n if compression is None:\\n compression = dpdr.default_compression\\n if settings.DEPENDER_DEBUG:\\n compression = \\\"none\\\"\\n\\n if client == \\\"true\\\" and require.count(\\\"Depender.Client\\\") == 0:\\n require.append(\\\"Depender.Client\\\")\\n \\n includes = dpdr.get_dependencies(require, exclude, requireLibs, excludeLibs)\\n output = \\\"//No files included for build\\\"\\n if len(includes) > 0:\\n \\n libraries_and_copyrights = dict()\\n for i in includes:\\n libraries_and_copyrights[i.library] = i.copyright\\n\\n output = \\\"\\\"\\n for lib, copy in libraries_and_copyrights.iteritems():\\n if len(copy) > 0:\\n output += copy + \\\"\\\\n\\\"\\n\\n output += \\\"\\\\n//Contents: \\\"\\n output += \\\", \\\".join([ i.name for i in includes ])\\n output += \\\"\\\\n\\\\n\\\"\\n \\n location = request.META[\\\"SERVER_PROTOCOL\\\"].split(\\\"/\\\")[0].lower() + \\\"://\\\" + request.META[\\\"HTTP_HOST\\\"] + request.path\\n args = request.META[\\\"QUERY_STRING\\\"]\\n if args.find(\\\"download=\\\") >= 0:\\n clean = []\\n for arg in args.split(\\\"&\\\"):\\n if arg.find(\\\"download=\\\") == -1:\\n clean.append(arg)\\n args = '&'.join(clean)\\n\\n output += \\\"//This lib: \\\" + location + '?' + args\\n output += \\\"\\\\n\\\\n\\\"\\n\\n for i in includes:\\n output += i.compressed_content[compression] + \\\"\\\\n\\\\n\\\"\\n\\n if client == \\\"true\\\":\\n output += dpdr.get_client_js(includes, location)\\n\\n response = HttpResponse(output, content_type=\\\"application/x-javascript\\\")\\n \\n if (download == \\\"true\\\"):\\n response['Content-Disposition'] = 'attachment; filename=built.js'\\n return response\",\n \"def test_list_available_libraries(self):\\n _ = LibraryFactory.create(modulestore=self.store)\\n all_libraries = self.tools.list_available_libraries()\\n assert all_libraries\\n assert len(all_libraries) == 1\",\n \"def get_artifacts(self):\\n\\n self.clml_modules = list(\\n filter(lambda mod: mod.type_key == \\\"clml\\\", self.libm.get_lib().imported_modules)\\n )\\n self.clml_builds[\\\"file_header\\\"] = [self.MakeFileHeader.substitute()]\\n\\n for cmod in self.clml_modules:\\n (sub_module_name, clml_code) = CLMLGetSubModuleSrc(cmod).get_src()\\n self.clml_builds[sub_module_name] = clml_code\\n\\n main_code = []\\n main_code.append(\\n \\\"\\\"\\\"\\n std::vector<CLMLRunner> BuildModules(ToolArgs& args,\\n cl_platform_id arg_platform,\\n cl_context arg_context,\\n cl_device_id arg_device_id,\\n cl_command_queue arg_queue) {\\n std::vector<CLMLRunner> runners;\\\"\\\"\\\"\\n )\\n for key, val in self.clml_builds.items():\\n if key != \\\"file_header\\\":\\n main_code.append(\\n \\\"runners.push_back(\\\"\\n + key\\n + '(\\\"'\\n + key\\n + '\\\", args, arg_platform, arg_context, arg_device_id, arg_queue));'\\n )\\n main_code.append(\\\"return runners;}\\\")\\n self.clml_builds[\\\"MainBuild\\\"] = main_code\\n\\n for key, val in self.clml_builds.items():\\n self.gen_src.extend(val)\\n\\n return (self.get_clml_params(), self.gen_src)\",\n \"def libs(self):\\n return self['libs']\",\n \"def set_up(self):\\n self.path.state = self.path.gen.joinpath(\\\"state\\\")\\n if self.path.state.exists():\\n self.path.state.rmtree(ignore_errors=True)\\n self.path.state.mkdir()\\n\\n for script in self.given.get(\\\"scripts\\\", []):\\n script_path = self.path.state.joinpath(script)\\n\\n if not script_path.dirname().exists():\\n script_path.dirname().makedirs()\\n\\n script_path.write_text(self.given[\\\"scripts\\\"][script])\\n script_path.chmod(\\\"u+x\\\")\\n\\n for filename, contents in self.given.get(\\\"files\\\", {}).items():\\n self.path.state.joinpath(filename).write_text(contents)\\n\\n self.python = hitchpylibrarytoolkit.project_build(\\n \\\"commandlib\\\", self.path, self.given[\\\"python version\\\"]\\n ).bin.python\\n\\n self.example_py_code = (\\n ExamplePythonCode(self.python, self.path.state)\\n .with_code(self.given.get(\\\"code\\\", \\\"\\\"))\\n .with_setup_code(self.given.get(\\\"setup\\\", \\\"\\\"))\\n )\",\n \"def set_libraries(self, lst):\\n self.__libraries = lst\",\n \"def on_libRoot(self):\\n self.rf_libTree()\\n self.rf_libPath()\\n self.rf_libFileName()\\n self.rf_delInfo()\",\n \"def initFilters(CONFIG):\\n\\t#### String containing all the preLibraries file name\\n\\tpreLibraries = findFile(\\\"classification_result/prelibraries/TE\\\", \\\"*.fasta\\\")\\n\\n\\t#### String containing all the preLibraries file name\\n\\tnoCatLibrarie = findFile(\\\"classification_result/prelibraries/\\\", \\\"noCat.fasta\\\")\\n\\n\\tlistPrelibraries = []\\n\\t#### dictionnaries that will contains all the id's sequences for concerned libraries\\n\\tdicoLibraries={\\\"autonomousLib\\\":[], \\\"totalTELib\\\":[], \\\"totalRepeatLib\\\":[]}\\n\\n\\tlistPrelibraries.append(noCatLibrarie[0])\\n\\t#### Add all the name of prelibraries in listPrelibraries\\n\\tfor file in preLibraries:\\n\\t\\tlistPrelibraries.append(file)\\n\\n\\t#### Dictionnary that restain the final classification for a given sequence (helpfull for the intermediateLibraries)\\n\\tdicoFinalClassif={}\\n\\t#### Parse all the prelibrary\\n\\tprint(\\\"####\\tApply the filters to create the intermediate libraries\\\")\\n\\tcreateIntermediateLibraries(listPrelibraries, dicoLibraries, CONFIG, dicoFinalClassif)\\n\\n\\t#### List containing all the intermediate librarie file name\\n\\tintermediateLibraries = findFile(\\\"classification_result/intermediateLibraries\\\", \\\"*.fasta\\\")\\n\\n\\tprint(\\\"####\\tApply the cd-hit-est on the intermediate libraries\\\")\\n\\tapplyCDHIT(intermediateLibraries)\\n\\n\\tretriveFinalLibrarieSequences(intermediateLibraries, CONFIG, dicoFinalClassif, dicoLibraries)\\n\\n\\tprint(\\\"####\\tCreation of the three final libraries\\\")\\n\\tcreateFinalLibraries(intermediateLibraries, dicoLibraries)\\n\\n\\tprint(\\\"Number of sequences in autonomousTE : {nbAutonomous}\\\\nNumber of sequences in totalTE : {nbTotalTE}\\\\nNumber of sequences in totalRepeatLib : {nbRepeated}\\\".format(\\\\\\n\\tnbAutonomous=len(dicoLibraries[\\\"autonomousLib\\\"]), nbTotalTE=len(dicoLibraries[\\\"totalTELib\\\"]), nbRepeated=len(dicoLibraries[\\\"totalRepeatLib\\\"])))\",\n \"def create_mp3():\\n\\n #TODO: les roles ne devraient pas etre en dur\\n list_all_roles = [\\n [],\\n [\\\"morgan\\\"],\\n [\\\"oberon\\\"],\\n [\\\"mordred\\\"],\\n [\\\"morgan\\\", \\\"oberon\\\"],\\n [\\\"morgan\\\", \\\"mordred\\\"],\\n [\\\"oberon\\\", \\\"mordred\\\"],\\n [\\\"morgan\\\", \\\"oberon\\\", \\\"mordred\\\"]\\n ]\\n\\n for list_roles in list_all_roles:\\n\\n list_mp3 = [\\\"init.mp3\\\", \\\"serv_mord.mp3\\\"]\\n if \\\"oberon\\\" in list_roles:\\n list_mp3.append(\\\"oberon.mp3\\\")\\n list_mp3.append(\\\"red_identi.mp3\\\")\\n\\n if \\\"morgan\\\" in list_roles:\\n list_mp3.append(\\\"add_per_mor.mp3\\\")\\n\\n list_mp3.append(\\\"serv_mord.mp3\\\")\\n if \\\"mordred\\\" in list_roles:\\n list_mp3.append(\\\"mordred.mp3\\\")\\n list_mp3.extend([\\\"merlin_identi.mp3\\\", \\\"end.mp3\\\"])\\n\\n mp3_combined = AudioSegment.empty()\\n for mp3 in list_mp3:\\n mp3_combined += AudioSegment.from_mp3(\\\"resources/{}\\\".format(mp3))\\n\\n mp3_combined.export(\\\"resources/_{}.mp3\\\".format('-'.join(sorted(list_roles))), format=\\\"mp3\\\")\",\n \"def create_assets():\\n assets = {}\\n\\n # Load all static files\\n for root, dirs, files in os.walk(STATIC_DIR):\\n for fname in files:\\n filename = os.path.join(root, fname)\\n with open(filename, \\\"rb\\\") as f:\\n assets[os.path.relpath(filename, STATIC_DIR)] = f.read()\\n\\n # Collect pages\\n pages = {}\\n for fname in os.listdir(PAGES_DIR):\\n if fname.lower().endswith(\\\".md\\\"):\\n name = fname.split(\\\".\\\")[0].lower()\\n with open(os.path.join(PAGES_DIR, fname), \\\"rb\\\") as f:\\n md = f.read().decode()\\n pages[name] = Page(name, md)\\n\\n # todo: Collect blog posts\\n\\n # Get template\\n with open(os.path.join(THIS_DIR, \\\"template.html\\\"), \\\"rb\\\") as f:\\n html_template = f.read().decode()\\n\\n with open(os.path.join(THIS_DIR, \\\"style.css\\\"), \\\"rb\\\") as f:\\n css = f.read().decode()\\n css += \\\"/* Pygments CSS */\\\\n\\\" + HtmlFormatter(style=\\\"vs\\\").get_style_defs(\\n \\\".highlight\\\"\\n )\\n\\n # Generate pages\\n year = datetime.now().year\\n for page in pages.values():\\n page.prepare(pages.keys())\\n title = TITLE if page.name == \\\"index\\\" else TITLE + \\\" - \\\" + page.name\\n menu = create_menu(page)\\n html = html_template.format(\\n title=title, style=css, body=page.to_html(), menu=menu, year=year\\n )\\n print(\\\"generating\\\", page.name + \\\".html\\\")\\n assets[page.name + \\\".html\\\"] = html.encode()\\n\\n # Fix backslashes on Windows\\n for key in list(assets.keys()):\\n if \\\"\\\\\\\\\\\" in key:\\n assets[key.replace(\\\"\\\\\\\\\\\", \\\"/\\\")] = assets.pop(key)\\n\\n return assets\",\n \"def setup():\\n print('...')\\n # Make sure dirs exist\\n for directory in [DATA_DIR, DATA_INPUT_DIR, DATA_OUTPUT_DIR]:\\n os.makedirs(directory, exist_ok=True)\",\n \"def _create_assets(self):\\n\\n assets = Environment(self.app)\\n # jQuery is served as a standalone file\\n jquery = Bundle('js/jquery-*.min.js', output='gen/jquery.min.js')\\n # JavaScript is combined into one file and minified\\n js_all = Bundle('js/js_all/*.js',\\n filters='jsmin',\\n output='gen/app.min.js')\\n # SCSS (Sassy CSS) is compiled to CSS\\n scss_all = Bundle('scss/app.scss',\\n filters='libsass',\\n output='gen/app.css')\\n assets.register('jquery', jquery)\\n assets.register('js_all', js_all)\\n assets.register('scss_all', scss_all)\\n return assets\",\n \"def write_inits(project_name, root_dir):\\r\\n \\r\\n #Create our file paths first...\\r\\n test_init_path = get_file_path(root_dir, \\\"tests\\\", \\\"__init__.py\\\")\\r\\n project_init_path = get_file_path(root_dir, project_name, \\\"__init__.py\\\")\\r\\n \\r\\n #Write the test_init file first\\r\\n test_init = open(test_init_path, 'w')\\r\\n test_init.close()\\r\\n print_file(test_init_path)\\r\\n \\r\\n #Write the NAME_init second\\r\\n project_init = open(project_init_path, 'w')\\r\\n project_init.close()\\r\\n print_file(project_init_path)\",\n \"def build():\",\n \"def make(config):\\n # Create child folders\\n for func in (create_basic_structure,\\n copy_resources,\\n copy_databases,\\n copy_libraries,\\n copy_security,\\n copy_app_actions,\\n copy_pages,\\n create_application_info_file,\\n replace_all_guids):\\n\\n INFO(\\\"\\\")\\n INFO(\\\"+\\\"*70)\\n INFO(\\\"\\\")\\n func(config)\",\n \"def create_intermediate_files():\\n\\n dirs = (DIR_PAGE, DIR_SRGB, DIR_VTI, DIR_TIFF,\\n DIR_BACK, DIR_TEXT, DIR_FINAL)\\n \\n for dir in dirs:\\n try:\\n os.mkdir(os.path.join(cwd, dir))\\n except OSError, e:\\n print 'directory (', dir, ') already exists'\",\n \"def __init__(self):\\n self._ll = LowLevelLibs()\\n self._lib = self._ll.ratchet\",\n \"def __init__(self):\\n self._ll = LowLevelLibs()\\n self._lib = self._ll.ratchet\",\n \"def get_libraries(name_only=False):\\n\\n libs = list()\\n\\n dtf_db = sqlite3.connect(DTF_DB)\\n cur = dtf_db.cursor()\\n\\n # This just returns the name\\n if name_only:\\n\\n sql = ('SELECT name '\\n 'FROM libraries ')\\n\\n for lib in cur.execute(sql):\\n libs.append(lib[0])\\n\\n # This returns a list of items\\n else:\\n\\n sql = ('SELECT name, version, '\\n 'about, author '\\n 'FROM libraries '\\n 'ORDER BY name')\\n\\n cur.execute(sql)\\n\\n while True:\\n\\n item = dtf.core.item.Item()\\n line = cur.fetchone()\\n if line is None:\\n break\\n\\n item.type = dtf.core.item.TYPE_LIBRARY\\n item.name = line[0]\\n item.version = line[1]\\n item.about = line[2]\\n item.author = line[3]\\n\\n libs.append(item)\\n\\n return libs\",\n \"def initialize():\\n\\n # create plugin locations\\n for p in (cache_path, config_path, data_path):\\n p.mkdir(parents=False, exist_ok=True)\",\n \"def wheels():\\n with lcd(env.local_path):\\n put('./requirements.txt', '/srv/build/wheel_requirements.txt')\\n put('./etc/base_image/image_requirements.txt',\\n '/srv/build/requirements.txt')\\n\\n with cd('/srv/build/wheelhouse'):\\n run('rm -rf *.whl')\\n\\n compose(cmd='-f service.yml -p %s run --rm wheel-factory' %\\n env.project_name, path='/srv/build')\",\n \"def check_init_files_and_folders():\\n\\t#['cascade_wimb_bus_front_100_stages_1000_pos_3000_neg.xml', 'cascade_wimb_bus_front_33_stages_1000_pos_3000_neg_wrong.xml', 'color_detect_2.py', 'dedupe.py', 'detect_image_group_ku.py', 'detect_shape_5.py', 'get_cam_id_2.py', 'get_image_8.py', 'gui_hsv.py', 'knaps.py', 'knapsack_2.py', 'maps.html', 'program_detect_rectangle.zip', 'start_capture.py']\\n\\tfile_list=[\\n\\t#'cascade_wimb_bus_front_100_stages_1000_pos_3000_neg.xml', \\n\\t'models/cascade_wimb_bus_front_33_stages_1000_pos_3000_neg_wrong.xml', \\n\\t#'color_detect_2.py', \\n\\t#'dedupe.py', \\n\\t'detect_bus_haar_group.py', \\n\\t#'detect_shape_5.py', \\n\\t'get_cam_detail.py', \\n\\t'get_image.py', \\n\\t#'gui_hsv.py', \\n\\t#'knaps.py', \\n\\t#'knapsack_2.py', \\n\\t#'maps.html', \\n\\t#'program_detect_rectangle.zip', \\n\\t'start_wimb.py',\\n\\t'g.php',\\n\\t]\\n\\tdirectory_list=[\\n\\t'images',\\n\\t'images_bgs',\\n\\t'images_bgs_mask',\\n\\t#'images_bgs_result',\\n\\t'images_color',\\n\\t'images_haar',\\n\\t'images_haar_result',\\n\\t'images_number',\\n\\t'images_number_result',\\n\\t'models',\\n\\t'images_old',\\n\\t'text_number',\\n\\t]\\n\\t\\n\\tfor file_name in file_list: print 'file '+file_name+' existed: '+str(os.path.isfile(file_name))\\n\\tfor directory_name in directory_list: \\n\\t\\tprint 'directory '+directory_name+' existed: '+str(os.path.isdir(directory_name))\\n\\t\\tif not os.path.isdir(directory_name): \\n\\t\\t\\tos.makedirs(directory_name)\\n\\t\\tif \\\"images\\\" in directory_name: shutil.copy(path+'/g.php',path+'/'+directory_name+'/g.php')\",\n \"def bake(self, apps_and_models):\\n for app_label, models in iteritems(apps_and_models):\\n model_names = {model.__name__: self.get_field_names_for_model(model) for model in models}\\n self.create_directories(app_label)\\n self.create_init_files(app_label, model_names.keys(), models)\\n self.remove_empty_startapp_files(app_label)\\n for file_name in [\\\"forms\\\", \\\"admin\\\", \\\"serializers\\\"]:\\n file_path = \\\"%s/%s.py\\\" % (app_label, file_name)\\n template_path = \\\"django_baker/%s\\\" % (file_name)\\n self.create_file_from_template(file_path, template_path, {\\\"model_names\\\": model_names})\\n for model in models:\\n model_attributes = self.model_attributes(app_label, model)\\n self.create_files_from_templates(model_attributes)\",\n \"def init(self):\\n\\n # create directories\\n self.createDirectory(\\\"src\\\")\\n list_directories_name = {\\n \\\"Models\\\": True,\\n \\\"DTOs\\\": True,\\n \\\"Repositories\\\": True,\\n \\\"Services\\\": True,\\n \\\"Mappeurs\\\": True,\\n \\\"Ressources\\\": True,\\n \\\"Logs\\\": False,\\n \\\"Parsers\\\": False,\\n \\\"docker\\\": False,\\n \\\"Enums\\\": False,\\n \\\"Config\\\": False,\\n }\\n\\n for directory_name in list_directories_name:\\n self.createDirectory(\\\"src/\\\" + directory_name)\\n\\n self.createDirectory(\\\"src/Logs\\\")\\n open(\\\"src/Logs/debug.log\\\", \\\"w\\\").close()\\n open(\\\"src/Logs/info.log\\\", \\\"w\\\").close()\\n open(\\\"src/Logs/error.log\\\", \\\"w\\\").close()\\n\\n # test directories\\n self.createDirectory(\\\"Tests\\\")\\n for directory_name in list_directories_name.keys():\\n if list_directories_name[directory_name]:\\n self.createDirectory(\\\"Tests/\\\" + directory_name)\\n\\n # helpers Test\\n path = self.getPathFileInStatic(\\\"helpersTest.py\\\")\\n shutil.copy(path, \\\"Tests/helpersTest.py\\\")\\n\\n # Security config\\n path = self.getPathFileInStatic(\\\"security.py\\\")\\n shutil.copy(path, \\\"src/Config/SecurityConfig.py\\\")\\n\\n # Logger\\n path = self.getPathFileInStatic(\\\"logger.py\\\")\\n shutil.copy(path, \\\"src/Config/Logger.py\\\")\\n\\n self.createDirectory(\\\"Tests/Mocks\\\")\\n\\n self.writeAppFile()\\n\\n path = self.getPathFileInStatic(\\\"config.py\\\")\\n shutil.copy(path, \\\"src/Config/ApplicationConfig.py\\\")\\n self.info(\\\"[x] create config.py\\\")\\n # shutil.copy(getPathFileInStatic(\\\"__init__.py\\\"), \\\"src/__init__.py\\\")\\n # info(\\\"[x] create __init__.py\\\")\\n path = self.getPathFileInStatic(\\\"server.py\\\")\\n shutil.copy(path, \\\"server.py\\\")\\n self.info(\\\"[x] create server.py\\\")\\n path = self.getPathFileInStatic(\\\"docker-compose.test.yml\\\")\\n shutil.copy(path, \\\"src/docker/docker-compose.test.yml\\\")\\n self.info(\\\"[x] create docker-compose.test.yml\\\")\",\n \"def prepare_artifacts(configs, jar_list):\\n artifact_folder = os.path.join(configs[\\\"targetFolder\\\"],\\n datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S'))\\n print(\\\"Creating artifact folder {0}...\\\".format(artifact_folder))\\n os.makedirs(artifact_folder)\\n\\n download_and_delete_jars(configs, artifact_folder, jar_list)\\n copy_poms(configs, artifact_folder)\\n gpg_sign(configs, artifact_folder)\\n generate_checksum(artifact_folder)\\n\\n return artifact_folder\",\n \"def create_book_objects(content):\\n library = []\\n for book in content:\\n library.append(Book(book['Author'], book['Title'], book['Publisher'], book['Shelf'], book['Category'],\\n book['Subject']))\\n print('Your Library has been loaded.')\\n return library\",\n \"def add_installed_libraries(self, extra_libs = [\\\"SeleniumLibrary\\\",\\n \\\"SudsLibrary\\\",\\n \\\"RequestsLibrary\\\"]):\\n\\n libdir = os.path.dirname(robot.libraries.__file__)\\n loaded = []\\n for filename in os.listdir(libdir):\\n if filename.endswith(\\\".py\\\") or filename.endswith(\\\".pyc\\\"):\\n libname, ext = os.path.splitext(filename)\\n if (libname.lower() not in loaded and\\n not self._should_ignore(libname)):\\n\\n try:\\n self.add(libname)\\n loaded.append(libname.lower())\\n except Exception as e:\\n # need a better way to log this...\\n self.log.debug(\\\"unable to add library: \\\" + str(e))\\n\\n # I hate how I implemented this, but I don't think there's\\n # any way to find out which installed python packages are\\n # robot libraries.\\n for library in extra_libs:\\n if (library.lower() not in loaded and\\n not self._should_ignore(library)):\\n try:\\n self.add(library)\\n loaded.append(library.lower())\\n except Exception as e:\\n self.log.debug(\\\"unable to add external library %s: %s\\\" % \\\\\\n (library, str(e)))\",\n \"def setup():\\n\\n p4_slackbots = model.Project(\\\"Merch Website\\\", \\\"http://76.176.109.127:6969/\\\", \\\"/static/img/p4_slackbots.png\\\",\\n \\\"P4Slackbots\\\",\\n [\\\"Abhijay Deevi\\\", \\\"Kevin Do\\\", \\\"Travis Medley\\\", \\\"Paul Bokelman\\\", \\\"Gavin Theriault\\\"],\\n \\\"This project is a merch website that we created for our Youtube channels, \\\"\\n \\\"GodlyGoats and \\\"\\n \\\"Albertpani Compani. We have a lot of merch you can buy and other information.\\\")\\n\\n p4_hangman = model.Project(\\\"Music Website\\\", url_for('p4_hangman_bp.index'), \\\"/static/img/p4hangman.png\\\",\\n \\\"P4 Hangman\\\",\\n [\\\"Charlie Zhu\\\", \\\"Rohan Nallapati\\\", \\\"Rivan Nayak\\\", \\\"Sarah Xie\\\", \\\"Noah Pidding\\\"],\\n \\\"This website includes a portfolio of our projects we worked on this trimester as well \\\"\\n \\\"as a music section including three different genres of music with multiple examples \\\"\\n \\\"and descriptions of each.\\\")\\n\\n p4_fruitycoders = model.Project(\\\"Photography Website\\\", \\\"google.com\\\", \\\"/static/img/p4_fruitycoders.png\\\",\\n \\\"P4 fruitycoders\\\",\\n [\\\"Sophie Lee\\\", \\\"Linda Long\\\", \\\"Maggie Killada\\\", \\\"Adam Holbel\\\", \\\"Wenshi Bao\\\"],\\n \\\"Our website (Fruity Photos) features the history of photography, as well as the \\\"\\n \\\"works \\\"\\n \\\"and biographies of several famous photographers, such as Ansel Adams and Annie \\\"\\n \\\"Leibovitz.\\\")\\n\\n \\\"\\\"\\\"p4_coderjoes = model.Project(\\\"CoderJoes Store\\\", url_for('p4_coderjoes_bp.index'), \\\"/static/img/p4_coderjoes.png\\\",\\n \\\"P4 Guessers\\\",\\n [\\\"Lola Bulkin\\\", \\\"Grace Le\\\", \\\"Ryan Moghaddas\\\", \\\"William Cherres\\\", \\\"Brayden Basinger\\\"],\\n \\\"CoderJoes is a virtual store where you can find recipes, ideas, and descriptions, \\\"\\n \\\"as well as a group portfolio of our work over the trimester.\\\")\\\"\\\"\\\"\\n\\n projects = [p4_slackbots, p4_hangman, p4_fruitycoders]#, p4_coderjoes\\n period = model.Period(\\\"Period 4\\\", \\\"AP Principles of Computer Science - Python\\\", projects)\\n return period\",\n \"def _create_chain(class_type_list, kwargs_list):\\n chain = None # module with preprocessing chain\\n modules = [] # list of modules (not connected via preprocessing)\\n for i, pre_id in enumerate(class_type_list):\\n chain = CModule.create(\\n pre_id, preprocess=chain, **kwargs_list[i])\\n modules.append(CModule.create(pre_id, **kwargs_list[i]))\\n return chain, modules\",\n \"def generate(self, info):\\n root = ET.Element(\\\"libs\\\")\\n\\n # Set target\\n target = ET.SubElement(root, \\\"target\\\")\\n target.text = info.target\\n\\n # Set time info\\n time_start = ET.SubElement(root, \\\"start_time\\\")\\n time_start.text = info.start_time.strftime(\\\"%H-%m-%Y %H:%M:%S\\\")\\n\\n time_end = ET.SubElement(root, \\\"end_time\\\")\\n time_end.text = info.end_time.strftime(\\\"%H-%m-%Y %H:%M:%S\\\")\\n\\n # WordPress info\\n wordpress = ET.SubElement(root, \\\"wordpress\\\")\\n wordpress.set(\\\"current_version\\\", info.wordpress_info.current_version)\\n wordpress.set(\\\"last_version\\\", info.wordpress_info.latest_version)\\n\\n # Set CVE\\n if info.wordpress_info.vulnerabilities:\\n cves = ET.SubElement(wordpress, \\\"cves\\\")\\n for cve in info.wordpress_info.vulnerabilities:\\n xml_cve = ET.SubElement(cves, \\\"cve\\\")\\n xml_cve.text = cve\\n\\n # Plugins info\\n plugins = ET.SubElement(root, \\\"plugins\\\")\\n for plugin in info.plugins:\\n xml_plugin = ET.SubElement(plugins, \\\"plugin\\\")\\n xml_plugin.text = plugin.plugin_name\\n\\n xml_plugin.set(\\\"current_version\\\", plugin.current_version)\\n xml_plugin.set(\\\"last_version\\\", plugin.latest_version)\\n xml_plugin.set(\\\"url\\\", plugin.plugin_uri)\\n xml_plugin.set(\\\"outdated\\\", \\\"Yes\\\" if plugin.is_outdated else \\\"No\\\")\\n\\n # Set CVE\\n if plugin.cves:\\n cves = ET.SubElement(xml_plugin, \\\"cves\\\")\\n for cve in plugin.cves:\\n xml_cve = ET.SubElement(cves, \\\"cve\\\")\\n xml_cve.text = cve\\n\\n # Set exploits\\n if plugin.cves:\\n exploits = ET.SubElement(xml_plugin, \\\"exploits\\\")\\n for exploit in plugin.exploits:\\n xml_exploit = ET.SubElement(exploits, \\\"exploits\\\")\\n xml_exploit.text = exploit\\n\\n return root\",\n \"def create_package(args, api, command_obj, resume=False):\\n set_subcommand_file(args.output_dir)\\n if resume:\\n retrieve_subcommands()\\n # read the metadata.json information\\n message = ('Reading the metadata.json files.........\\\\n')\\n u.log_message(message, log_file=session_file,\\n console=args.verbosity)\\n package_dir = args.package_dir\\n output_dir = args.output_dir\\n metadata_file = os.path.join(package_dir, METADATA_FILE)\\n metadata = None\\n\\n with open(metadata_file) as metadata_handler:\\n metadata = json.load(metadata_handler)\\n # recurse into components/directories, if any\\n if metadata.get(\\\"kind\\\") == \\\"package\\\" and 'components' in metadata:\\n components = metadata.get(\\\"components\\\")\\n for component in components:\\n message = ('Inspecting component %s.........\\\\n' % component)\\n u.log_message(message, log_file=session_file,\\n console=args.verbosity)\\n args.package_dir = os.path.join(package_dir, component)\\n create_package(args, api, command_obj, resume=resume)\\n args.package_dir = package_dir\\n else:\\n # create libraries or scripts\\n imports = []\\n category = str(metadata.get(\\\"category\\\", DFT_CATEGORY))\\n if metadata.get(\\\"imports\\\") is not None:\\n lib_imports = metadata.get(\\\"imports\\\")\\n for lib_import in lib_imports:\\n args.package_dir = os.path.join(package_dir, lib_import)\\n if args.embed_libs:\\n library_ref = create_package( \\\\\\n args, api, command_obj, resume=resume)\\n u.log_created_resources(\\\"imports\\\",\\n output_dir, library_ref)\\n else:\\n try:\\n # try to read the library id, if it is already there\\n library_ref = read_library_id(os.path.join( \\\\\\n output_dir, os.path.basename(args.package_dir)))\\n except IOError:\\n library_ref = create_package( \\\\\\n args, api, command_obj, resume=resume)\\n library_ref = read_library_id(os.path.join( \\\\\\n output_dir, os.path.basename(args.package_dir)))\\n imports.append(library_ref)\\n args.package_dir = package_dir\\n # read the metadata.json information\\n message = ('Creating the %s.........\\\\n' % metadata.get(\\\"kind\\\"))\\n u.log_message(message, log_file=session_file,\\n console=args.verbosity)\\n if metadata.get(\\\"kind\\\") in WHIZZML_RESOURCES:\\n whizzml_code = os.path.normpath(os.path.join(args.package_dir, \\\\\\n metadata.get(\\\"source_code\\\", \\\"%s.whizzml\\\" % \\\\\\n metadata.get(\\\"kind\\\"))))\\n if args.embed_libs and metadata.get(\\\"kind\\\") == WHIZZML_LIBRARY:\\n return whizzml_code\\n\\n args.output_dir = os.path.join(output_dir, \\\\\\n os.path.basename(package_dir))\\n # creating command to create the resource\\n command = COMMANDS[metadata.get(\\\"kind\\\")] % (whizzml_code,\\n args.output_dir)\\n command_args = command.split()\\n bigml.util.check_dir(args.output_dir)\\n\\n # getting inputs and outputs for the script from metadata\\n if \\\"inputs\\\" in metadata:\\n inputs_file = os.path.join(args.output_dir, \\\"inputs.json\\\")\\n u.write_to_utf8(inputs_file, json.dumps(metadata.get(\\\"inputs\\\")))\\n command_args.extend([\\\"--declare-inputs\\\", inputs_file])\\n if \\\"outputs\\\" in metadata:\\n outputs_file = os.path.join(args.output_dir, \\\"outputs.json\\\")\\n u.write_to_utf8(outputs_file, json.dumps(metadata.get(\\\"outputs\\\")))\\n command_args.extend([\\\"--declare-outputs\\\", outputs_file])\\n if \\\"description\\\" in metadata:\\n desc_file = os.path.join(args.output_dir, \\\"description.txt\\\")\\n u.write_to_utf8(desc_file, metadata.get(\\\"description\\\"))\\n command_args.extend([\\\"--description\\\", desc_file])\\n if metadata.get(\\\"name\\\"):\\n command_args.extend([\\\"--name\\\", metadata.get(\\\"name\\\")])\\n if args.tag:\\n for tag in args.tag:\\n command_args.extend([\\\"--tag\\\", tag])\\n command_args.extend([\\\"--category\\\", category])\\n\\n # adding imports, if any\\n if imports:\\n if args.embed_libs:\\n # imports to be embedded are in the same output directory\\n command_args.extend( \\\\\\n [\\\"--embedded-imports\\\", os.path.join(output_dir,\\n \\\"imports\\\")])\\n else:\\n # imports to be refereced by ID\\n command_args.extend([\\\"--imports\\\", \\\",\\\".join(imports)])\\n command_args.extend([\\\"--verbosity\\\", str(args.verbosity)])\\n command_obj.propagate(command_args)\\n # u.add_api_context(command_args, args)\\n if args.upgrade:\\n command_args.extend([\\\"--upgrade\\\"])\\n\\n if resume:\\n next_command = subcommand_list.pop()\\n if different_command(next_command, command):\\n resume = False\\n u.sys_log_message(command, log_file=subcommand_file)\\n execute_dispatcher(args=command_args)\\n elif not subcommand_list:\\n execute_dispatcher(args=['execute', '--resume'])\\n resume = False\\n else:\\n u.sys_log_message(command, log_file=subcommand_file)\\n execute_dispatcher(args=command_args)\\n args.output_dir = output_dir\\n return whizzml_code\\n return \\\"\\\"\",\n \"def _build_datasets(self):\\n self._build_datasets_sis3302()\\n self._build_datasets_sis3305()\",\n \"def _setup(self):\\n self._raw_dir = os.path.join(self._snippets_dir,\\\"raw\\\",\\\"static\\\")\\n if not os.path.exists(self._raw_dir):\\n os.mkdir(self._raw_dir)\\n\\n self._trec_dir = os.path.join(self._snippets_dir,\\\"trec\\\",\\\"static\\\")\\n if not os.path.exists(self._trec_dir):\\n os.mkdir(self._trec_dir)\\n\\n self._temp_dir = os.path.join(self._snippets_dir,\\\"temp\\\",\\\"static\\\")\\n if not os.path.exists(self._temp_dir):\\n os.mkdir(self._temp_dir)\\n\\n self._para_dir = os.path.join(self._snippets_dir,\\\"para\\\",\\\"static\\\")\\n if not os.path.exists(self._para_dir):\\n os.mkdir(self._para_dir)\\n\\n self._snippet_result_dir = os.path.join(self._snippets_dir,\\\"result\\\",\\\"static\\\")\\n if not os.path.exists(self._snippet_result_dir):\\n os.mkdir(self._snippet_result_dir)\\n\\n self._snippet_index_dir = os.path.join(self._snippets_dir,\\\"index\\\",\\\"static\\\")\\n if not os.path.exists(self._snippet_index_dir):\\n os.mkdir(self._snippet_index_dir)\\n\\n \\n\\n\\n self._index_para = os.path.join(self._para_dir,\\\"index_para\\\")\\n\\n self._temp_query_para = os.path.join(self._para_dir,\\\"temp_query_para\\\")\\n\\n self._index_list = os.path.join(self._para_dir,\\\"static_index_list\\\")\\n \\n self._orf = os.path.join(self._snippet_result_dir,\\\"orf\\\")\\n\\n self._oqf = os.path.join(self._temp_dir,\\\"oqf\\\")\\n \\n self._temp_output = os.path.join(self._temp_dir,\\\"temp_output\\\")\\n\\n with open(self._index_list,\\\"w\\\") as f:\\n f.write(self._snippet_index_dir+\\\"\\\\n\\\")\\n\\n self._temp_query_builder = IndriQueryFactory(count=10000,\\n rule=self._retrieval_method)\\n\\n self._oqf_builder = IndriQueryFactory(count=30,\\n rule=self._retrieval_method)\",\n \"def main():\\n os.makedirs(PATH)\\n fetch_data()\\n convert_to_json(model_list, 'models.json', is_model=True)\\n convert_to_json(backend_list, 'backends.json')\\n convert_to_json(type_list, 'types.json')\\n convert_to_json(featurizer_list, 'featurizers.json')\",\n \"def KengeLibrary(self, name, buildname=None, source = None, public_headers = None, **kargs):\\n library_args = {}\\n\\n library_args[\\\"CPPPATH\\\"] = []\\n\\n if buildname is None:\\n buildname = name\\n\\n if source is None:\\n # User didn't provide any source files\\n # explicitly, so we work out it form them\\n # based on some hueristics.\\n glob_list = []\\n dirs = [\\\"include/interfaces/\\\", \\\"src/\\\", \\\"src/arch-%s/\\\" % env.arch]\\n\\t if self.test_lib == name:\\n\\t\\tdirs.append(\\\"test/\\\")\\n if self[\\\"BUILD_TESTS\\\"]:\\n dirs += [\\\"test/\\\"]\\n for src_ext in env.src_exts:\\n for dir_ in dirs:\\n glob_list.append(dir_ + \\\"*.\\\" + src_ext)\\n else:\\n glob_list = source\\n\\n libs = []\\n \\n if \\\"LIBS\\\" in kargs:\\n if self[\\\"BUILD_TESTS\\\"]:\\n kargs[\\\"LIBS\\\"].append(\\\"check\\\")\\n for lib in kargs[\\\"LIBS\\\"]:\\n libs.append(lib)\\n if lib not in self.libs.keys():\\n raise SCons.Errors.UserError, \\\"Library [%s] was looking for library [%s] but it doesn't exist \\\" \\\\\\n \\\"in environment [%s]\\\\n This environment has: %s\\\" % (name, lib, self.name, self.libs.keys())\\n\\n del kargs[\\\"LIBS\\\"]\\n\\n # He we expand the glob to a list of files\\n source_list = Flatten([src_glob(glob) for glob in glob_list])\\n\\n idl_files = [fn for fn in source_list if fn.endswith(\\\".idl4\\\")]\\n reg_files = [fn for fn in source_list if fn.endswith(\\\".reg\\\")]\\n\\n # Now we go through everything in the kargs:\\n for arg in kargs:\\n if arg.startswith(\\\"EXTRA_\\\"):\\n argname = arg[6:]\\n library_args[argname] = self[argname] + kargs[arg]\\n else:\\n library_args[arg] = kargs[arg]\\n\\n # Generally this is the only public headers\\n if public_headers is None:\\n public_headers = [\\\"#libs/%s/include\\\" % name, \\\"#libs/%s/test\\\" % name]\\n\\n if len(idl_files) or len(reg_files):\\n # Unless we have generated files\\n public_headers.append(Dir(\\\".\\\").abspath + \\\"/include\\\")\\n\\n # Now if we are for real compiling stuff...\\n cpp_path = copy.copy(self[\\\"CPPPATH\\\"])\\n\\tif self.test_lib:\\n\\t\\tcpp_path.append(\\\"#libs/check/include\\\")\\n \\n # Make sure we include any of the libraries header file's\\n for each in public_headers:\\n cpp_path.append(each)\\n\\n # This ensure that any generated header files\\n # Maybe move this somewhere else later though\\n cpp_path.append(Dir('.').abspath + \\\"/src\\\") # Broken\\n cpp_path.append(Dir('.').abspath + \\\"/include\\\")\\n\\n # Find any .idl4 files that should be generated\\n for file in idl_files:\\n gen_file = self.IDL4(file)\\n\\n # Generate any .reg files\\n for file in reg_files:\\n self.Reg(file)\\n \\n library_args[\\\"CPPPATH\\\"] += cpp_path + self.end_cpp_path # End cpp_path is a hack hack hack!\\n \\n # Now we just call the normal StaticLibrary with our simple defaults\\n lib = self.StaticLibrary(buildname, source_list, **library_args)\\n\\n assert(len(lib) == 1)\\n lib = lib[0]\\n\\n if self[\\\"FLINT_RUN\\\"]:\\n for each in lib.children():\\n if str(each).endswith(\\\".o\\\"):\\n if str(each.children()[0]).endswith(\\\".c\\\") or \\\\\\n str(each.children()[0]).endswith(\\\".cc\\\"):\\n self.AddPreAction(each, \\\"$FLINTCOM\\\")\\n\\n # And construct our definition of the library\\n # This should suck muhc much less... how about a class?\\n lib = (public_headers, lib, \\\"#\\\" + os.path.dirname(lib.path), None, libs)\\n return lib\",\n \"def initialize_folders(self):\\n logger.info('Initializing folders')\\n create_folder(self.generator_folder)\\n create_folder(self.data_folder)\\n create_folder(self.input_folder)\\n create_folder(self.filtered_folder)\\n create_folder(self.model_folder)\\n create_folder(self.build_folder)\",\n \"def create(cls, user, master_mix, water, robot, tm300_8_tool, tm50_8_tool,\\n volume, plates):\\n with sql_connection.TRN as TRN:\\n # Add the row to the process table\\n process_id = cls._common_creation_steps(user)\\n\\n # Add the row to the library_prep_16s_process\\n sql = \\\"\\\"\\\"INSERT INTO qiita.library_prep_16s_process\\n (process_id, master_mix_id, tm300_8_tool_id,\\n tm50_8_tool_id, water_id, processing_robot_id)\\n VALUES (%s, %s, %s, %s, %s, %s)\\n RETURNING library_prep_16s_process_id\\\"\\\"\\\"\\n TRN.add(sql, [process_id, master_mix.id, tm300_8_tool.id,\\n tm50_8_tool.id, water.id, robot.id])\\n instance = cls(TRN.execute_fetchlast())\\n\\n for gdna_plate, primer_plate in plates:\\n # Create the library plate\\n plate_ext_id = '16S library - %s' % gdna_plate.external_id\\n\\n plate_config = gdna_plate.plate_configuration\\n library_plate = plate_module.Plate.create(plate_ext_id,\\n plate_config)\\n gdna_layout = gdna_plate.layout\\n primer_layout = primer_plate.layout\\n for i in range(plate_config.num_rows):\\n for j in range(plate_config.num_columns):\\n well = container_module.Well.create(\\n library_plate, instance, volume, i + 1, j + 1)\\n composition_module.LibraryPrep16SComposition.create(\\n instance, well, volume,\\n gdna_layout[i][j].composition,\\n primer_layout[i][j].composition)\\n\\n return instance\",\n \"def create_database(self):\\n\\n try: \\n connection = sqlite3.connect(self.filepath_render_database)\\n pointer = connection.cursor()\\n\\n print(self.filepath_render_database)\\n\\n sql_instruction = \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS render_information(\\n \\n object_type VARCHAR(255),\\n name VARCHAR(255),\\n radius REAL,\\n polar_angle_min REAL,\\n polar_anglel_max REAL,\\n polar_angle_segments REAL,\\n polar_angle_random_rad REAL,\\n azimuth_angle_min REAL,\\n azimuth_angle_max REAL,\\n azimuth_angle_segments REAL,\\n azimuth_angle_random_rad REAL,\\n tracking_obj VARCHAR(255),\\n segmentation VARCHAR(255)\\n\\n\\n );\\\"\\\"\\\"\\n pointer.execute(sql_instruction)\\n connection.commit()\\n connection.close()\\n print(\\\"Creating render database file\\\")\\n except:\\n print(\\\"Was not able to create render database file\\\")\\n \\n try: \\n connection = sqlite3.connect(self.filepath_object_database)\\n pointer = connection.cursor()\\n sql_instruction = \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS object_information(\\n obj_filepath VARCHAR(255),\\n obj_name VARCHAR(255),\\n obj_type VARCHAR(255),\\n obj_scale_factor REAL,\\n obj_location_x REAL,\\n obj_location_y REAL,\\n obj_location_z REAL,\\n obj_rotation_x REAL,\\n obj_rotation_y REAL,\\n obj_rotation_z REAL,\\n obj_amount_percent REAL,\\n obj_material_path VARCHAR(255),\\n obj_point_in_time VARCHAR(255),\\n maximum_random_rotation_degree_z REAL,\\n maximum_random_translation REAL,\\n random_amount REAL\\n );\\\"\\\"\\\"\\n pointer.execute(sql_instruction)\\n connection.commit()\\n connection.close()\\n print(\\\"Creating object database file\\\")\\n except:\\n print(\\\"Was not able to create object database file\\\")\\n\\n try: \\n connection = sqlite3.connect(self.filepath_output_database)\\n print(\\\"outputfilepath is:\\\", self.filepath_output_database)\\n pointer = connection.cursor()\\n sql_instruction = \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS objects(\\n image_id REAL,\\n object_name VARCHAR(255),\\n object_type VARCHAR(255),\\n object_amount REAL,\\n object_location_x REAL,\\n object_location_y REAL,\\n object_location_z REAL,\\n object_rotation_x REAL,\\n object_rotation_y REAL,\\n object_rotation_z REAL,\\n object_dimensions_x REAL,\\n object_dimensions_y REAL,\\n object_dimensions_z REAL\\n );\\\"\\\"\\\"\\n pointer.execute(sql_instruction)\\n connection.commit()\\n sql_instruction = \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS camera_settings(\\n image_id REAL,\\n image_variation REAL,\\n camera_name VARCHAR(255),\\n camera_location_x REAL,\\n camera_location_y REAL,\\n camera_location_z REAL,\\n camera_rotation_x REAL,\\n camera_rotation_y REAL,\\n camera_rotation_z REAL,\\n camera_focal_length REAL,\\n camera_polar_angle REAL,\\n camera_azimuth_angle REAL\\n );\\\"\\\"\\\"\\n pointer.execute(sql_instruction)\\n connection.commit()\\n sql_instruction = \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS light_settings(\\n image_id REAL,\\n image_variation REAL,\\n light_name VARCHAR(255),\\n light_location_x REAL,\\n light_location_y REAL,\\n light_location_z REAL,\\n light_rotation_x REAL,\\n light_rotation_y REAL,\\n light_rotation_z REAL,\\n light_intensity REAL,\\n light_polar_angle REAL,\\n light_azimuth_angle REAL\\n );\\\"\\\"\\\"\\n pointer.execute(sql_instruction)\\n connection.commit()\\n sql_instruction = \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS general_settings(\\n image_id REAL,\\n render_type VARCHAR(255),\\n render_frame REAL\\n );\\\"\\\"\\\"\\n pointer.execute(sql_instruction)\\n connection.commit()\\n sql_instruction = \\\"\\\"\\\"\\n CREATE TABLE IF NOT EXISTS bounding_boxes(\\n image_id REAL,\\n image_variation REAL,\\n object_name VARCHAR(255),\\n object_type VARCHAR(255),\\n min_x REAL,\\n max_x REAL,\\n min_y REAL,\\n max_y REAL\\n );\\\"\\\"\\\"\\n pointer.execute(sql_instruction)\\n connection.commit()\\n connection.close()\\n print(\\\"Creating output database file\\\")\\n except:\\n print(\\\"Was not able to create output database file\\\")\",\n \"def build_context():\\n threejs_url = 'https://www.gstatic.com/external_hosted/threejs-r98/'\\n _publish.javascript(url=threejs_url + 'three.min.js')\\n _publish.javascript(url=threejs_url + 'examples/js/controls/OrbitControls.js')\\n return _js_builder.Js(mode=_js_builder.PERSISTENT)\",\n \"def setup(conf, products, build=False):\\n import distutils.sysconfig\\n paths = {\\n \\\"CPPPATH\\\": distutils.sysconfig.get_python_inc().split(),\\n \\\"LIBPATH\\\": [],\\n }\\n libs = []\\n dir = distutils.sysconfig.get_config_var(\\\"LIBPL\\\")\\n if not dir in paths[\\\"LIBPATH\\\"]:\\n paths[\\\"LIBPATH\\\"] += [dir]\\n pylibrary = distutils.sysconfig.get_config_var(\\\"LIBRARY\\\")\\n mat = re.search(\\\"(python.*)\\\\.(a|so|dylib)$\\\", pylibrary)\\n if mat:\\n libs.append(mat.group(1)) \\n for w in (\\\" \\\".join([distutils.sysconfig.get_config_var(\\\"MODLIBS\\\"),\\n distutils.sysconfig.get_config_var(\\\"SHLIBS\\\")])).split():\\n mat = re.search(r\\\"^-([Ll])(.*)\\\", w)\\n if mat:\\n lL = mat.group(1)\\n arg = mat.group(2)\\n if lL == \\\"l\\\":\\n if not arg in libs:\\n libs.append(arg)\\n else:\\n if os.path.isdir(arg) and not arg in paths[\\\"LIBPATH\\\"]:\\n paths[\\\"LIBPATH\\\"].append(arg)\\n conf.env.PrependUnique(**paths)\\n for lib in libs:\\n if lib not in conf.env.libs[\\\"python\\\"]:\\n conf.env.libs[\\\"python\\\"].append(lib)\\n return {\\\"paths\\\": paths, \\\"libs\\\": {\\\"python\\\": libs}}\",\n \"def _on_library_new(self, evt=None):\\n \\n # raise save dialog\\n wildcard = \\\"Papyrus library format|*.papyrus\\\"\\n dlg = wx.FileDialog(self, \\\"New Papyrus Library\\\", \\\"\\\", \\\"library.papyrus\\\", wildcard=wildcard, style=wx.FD_SAVE)\\n if dlg.ShowModal() == wx.ID_OK:\\n path = dlg.GetPath()\\n dlg.Destroy()\\n else:\\n dlg.Destroy()\\n return\\n \\n # init library\\n try:\\n core.Library(path, new=True)\\n except:\\n wx.Bell()\\n dlg = mwx.MessageDlg(self, -1, \\\"Cannot create the library.\\\", \\\"Please check access permissions.\\\", \\\"Error\\\")\\n dlg.ShowModal()\\n dlg.Destroy()\\n return\\n \\n # open library\\n self.OpenDocuments([path])\",\n \"def create_library(cls, service_uid, library_data):\\n\\n library_data = BaseView.helper_validate_library_data(\\n service_uid=service_uid,\\n library_data=library_data\\n )\\n _name = library_data.get('name')\\n _description = library_data.get('description')\\n _public = bool(library_data.get('public', False))\\n _bibcode = library_data.get('bibcode', False)\\n\\n with current_app.session_scope() as session:\\n try:\\n # Make the library in the library table\\n library = Library(name=_name,\\n description=_description,\\n public=_public)\\n\\n # If the user supplies bibcodes\\n if _bibcode and isinstance(_bibcode, list):\\n\\n # Ensure unique content\\n _bibcode = uniquify(_bibcode)\\n current_app.logger.info('User supplied bibcodes: {0}'\\n .format(_bibcode))\\n library.add_bibcodes(_bibcode)\\n elif _bibcode:\\n current_app.logger.error('Bibcode supplied not a list: {0}'\\n .format(_bibcode))\\n raise TypeError('Bibcode should be a list.')\\n\\n user = session.query(User).filter_by(id = service_uid).one()\\n\\n # Make the permissions\\n permission = Permissions(\\n owner=True,\\n )\\n\\n # Use the ORM to link the permissions to the library and user,\\n # so that no commit is required until the complete action is\\n # finished. This means any rollback will not leave a single\\n # library without permissions\\n library.permissions.append(permission)\\n user.permissions.append(permission)\\n\\n session.add_all([library, permission, user])\\n session.commit()\\n\\n current_app.logger.info('Library: \\\"{0}\\\" made, user_service: {1:d}'\\n .format(library.name, user.id))\\n\\n library_dict = dict(\\n name=library.name,\\n id='{0}'.format(cls.helper_uuid_to_slug(library.id)),\\n description=library.description,\\n )\\n # If they added bibcodes include in the response\\n if hasattr(library, 'bibcode') and library.bibcode:\\n library_dict['bibcode'] = library.get_bibcodes()\\n return library_dict\\n\\n except IntegrityError as error:\\n # Roll back the changes\\n session.rollback()\\n current_app.logger.error('IntegitryError, database has been rolled'\\n 'back. Caused by user_service: {0:d}.'\\n 'Full error: {1}'\\n .format(user.id, error))\\n # Log here\\n raise\\n except Exception:\\n session.rollback()\\n raise\",\n \"def create_components():\\n reset_uuid()\\n # pylint: disable=protected-access\\n controllers = []\\n for compstr in dir(control):\\n comp = getattr(control, compstr)\\n if (compstr[0] != '_' and isclass(comp) and issubclass(comp, control._Controller)\\n and compstr != 'Upload'):\\n controllers.append(comp())\\n\\n for controller in controllers:\\n assert COMPONENT_REGISTRY[controller._uuid] == controller\\n\\n visuals = []\\n for compstr in dir(visual):\\n comp = getattr(visual, compstr)\\n if compstr[0] != '_' and isclass(comp) and issubclass(comp, visual._Visual):\\n visuals.append(comp())\\n\\n for vis in visuals:\\n assert COMPONENT_REGISTRY[vis._uuid] == vis\\n\\n htmls = []\\n for compstr in dir(html):\\n comp = getattr(html, compstr)\\n if compstr[0] != '_' and isclass(comp) and issubclass(comp, html._HTML):\\n htmls.append(comp())\\n\\n for htm in htmls:\\n assert COMPONENT_REGISTRY[htm._uuid] == htm\\n\\n return controllers, visuals, htmls\",\n \"def elinos_init():\\n elinos_env = get_elinos_environment()\\n\\n solib_dirs = []\\n\\n # System libraries\\n if None in (elinos_env[key] for key in (\\\"cdk\\\", \\\"target\\\")):\\n warn(\\\"ELinOS system libraries will not be loaded\\\")\\n else:\\n solib_prefix = \\\"%s/%s\\\" % (elinos_env[\\\"cdk\\\"], elinos_env[\\\"target\\\"])\\n solib_dirs += [\\\"%s/%s\\\" % (solib_prefix, \\\"lib\\\")]\\n gdb.execute(\\\"set solib-absolute-prefix %s\\\" % solib_prefix)\\n\\n # Xenomai libraries. Those are optional, so have a lighter warning\\n # if they cannot be located.\\n if elinos_env[\\\"project\\\"] is None:\\n warn(\\\"Xenomai libraries may not be loaded\\\")\\n else:\\n for dir in elinos_env['xenomai']:\\n solib_dirs += [\\\"%s/%s\\\"\\n % (dir, \\\"xenomai-build/usr/realtime/lib\\\")]\\n\\n if len(solib_dirs) != 0:\\n gdb.execute(\\\"set solib-search-path %s\\\" % \\\":\\\".join(solib_dirs))\",\n \"def init_objects():\\n gravity = Gravity()\\n planet_stencil = PlanetStencil()\\n return gravity, planet_stencil\",\n \"def create_allcomponents(self):\\n\\n # we store all components in a list/hash which we iterate for startup/shutdown/dumps debugging, and which can be used to lookup components\\n self.components = MDictList()\\n\\n # setup log manager helper early so that log manager can receive messages (and queue them until startup)\\n self.createappendcomp('logmanager', mlogger.MewloLogManager)\\n\\n # now update site state (log manager should catch this)\\n self.set_statelabel(mconst.DEF_SITESTATE_INITIALIZE_START)\\n\\n # create (non-db-persistent) site settings -- these are set by configuration at runtime\\n self.settings = self.createappendcomp('settings', MewloSettings)\\n\\n # database manager\\n self.createappendcomp('dbmanager', mdbmanager_sqlalchemy.MewloDatabaseManagerSqlA)\\n\\n # component registry\\n self.createappendcomp('registrymanager', mregistry.MewloRegistryManager)\\n\\n # signal dispatcher\\n self.createappendcomp('signalmanager', msignal.MewloSignalManager)\\n\\n # rbac permission manager\\n self.createappendcomp('rbacmanager', mrbac.MewloRbacManager)\\n\\n # create persistent(db) pack settings\\n self.createappendcomp('packsettings', mdbsettings_pack.MewloSettingsDb_Pack)\\n\\n # collection of mewlo addon packs\\n self.createappendcomp('packmanager', mpackmanager.MewloPackManager)\\n\\n # site addon manager\\n #self.createappendcomp('siteaddonmanager', msiteaddon.MewloSiteAddonManager)\\n\\n # route manager\\n self.createappendcomp('routemanager', mroute.MewloRouteManager)\\n\\n # navnode manager\\n self.createappendcomp('navnodemanager', mnav.NavNodeManager)\\n\\n # template manager\\n self.createappendcomp('templatemanager', mtemplate.MewloTemplateManager)\\n\\n # asset and alias manager\\n self.createappendcomp('assetmanager', massetmanager.MewloAssetManager)\\n\\n # template helper (this is available inside template/views and provides helper functions like navigation menus, etc.)\\n self.createappendcomp('templatehelper', mtemplatehelper.MewloTemplateHelper)\\n\\n # session manager\\n self.createappendcomp('sessionmanager', msessionmanager.MewloSessionManager)\\n\\n # verification manager\\n self.createappendcomp('verificationmanager', mverificationmanager.MewloVerificationManager)\\n\\n # user manager\\n self.createappendcomp('usermanager', musermanager.MewloUserManager)\\n\\n # mail manager\\n self.createappendcomp('mailmanager', mmailmanager.MewloMailManager)\",\n \"def post_hook(self):\\n self.mk_rg1()\\n self.mk_rg2()\\n self.mk_rg3()\",\n \"def _create_directories(self):\\n print \\\"[--init] creating directory structure in %s\\\" % (self.target_path)\\n ensure_path(self.conf_path)\\n for subdir in config.PROCESSING_AREAS:\\n subdir_path = self.data_path + os.sep + subdir\\n ensure_path(subdir_path)\",\n \"def setup():\\n for dir_path in [train_dir, output_dir]:\\n Path(dir_path).mkdir(exist_ok=True)\\n\\n # create the training and test data files that we will use\\n create_jsonlines_feature_files(train_dir)\",\n \"def write_dependencies(self):\\n\\n references = self.tree.xpath('//ns:ProjectReference', namespaces=self.ns)\\n if references:\\n self.cmake.write('################### Dependencies ##################\\\\n'\\n '# Add Dependencies to project. #\\\\n'\\n '###################################################\\\\n\\\\n')\\n self.cmake.write(\\n 'option(BUILD_DEPENDS \\\\n' +\\n ' \\\"Build other CMake project.\\\" \\\\n' +\\n ' ON \\\\n' +\\n ')\\\\n\\\\n'\\n )\\n self.cmake.write(\\n '# Dependencies : disable BUILD_DEPENDS to link with lib already build.\\\\n'\\n )\\n if self.dependencies is None:\\n self.cmake.write('if(BUILD_DEPENDS)\\\\n')\\n for ref in references:\\n reference = str(ref.get('Include'))\\n path_to_reference = os.path.splitext(ntpath.basename(reference))[0]\\n self.cmake.write(\\n ' add_subdirectory(platform/cmake/%s ${CMAKE_BINARY_DIR}/%s)\\\\n' % (\\n path_to_reference, path_to_reference\\n )\\n )\\n else:\\n self.cmake.write('if(BUILD_DEPENDS)\\\\n')\\n d = 1\\n for ref in self.dependencies:\\n self.cmake.write(\\n ' add_subdirectory(%s ${CMAKE_BINARY_DIR}/lib%s)\\\\n' % (ref, str(d)))\\n send(\\n 'Add manually dependencies : %s. Will be build in \\\"lib%s/\\\" !' % (\\n ref, str(d)),\\n 'warn'\\n )\\n d += 1\\n self.cmake.write('else()\\\\n')\\n for ref in references:\\n reference = str(ref.get('Include'))\\n path_to_reference = os.path.splitext(ntpath.basename(reference))[0]\\n self.cmake.write(\\n ' link_directories(dependencies/%s/build/)\\\\n' % path_to_reference\\n )\\n self.cmake.write('endif()\\\\n\\\\n')\\n else: # pragma: no cover\\n send('No link needed.', '')\",\n \"def get_libraries(self):\\r\\n\\r\\n #### Begin functionality here\\r\\n if debug: eprint(\\\"INFO: Fetching all libraries\\\")\\r\\n session = self.session\\r\\n libraries = session.query(LibraryRecord).all()\\r\\n return(libraries)\",\n \"def _add_jet_collection_and_dependencies(process, options, prefix, jet_algo_name, suffix, jet_kwargs):\\n\\n assert jet_algo_name in JET_COLLECTIONS, \\\"Unknown jet collection: {}\\\".format(jet_algo_name)\\n\\n _template_jet_collection_name = \\\"{}Jets{}\\\".format(prefix, jet_algo_name)\\n _template_met_collection_name = \\\"{}METs{}\\\".format(prefix, jet_algo_name)\\n _template_map_names = [\\n \\\"{}Jet{}Map{}\\\".format(prefix, _obj_name, jet_algo_name)\\n for _obj_name in ('TriggerObject', 'Muon', 'Electron')\\n ]\\n\\n process.add_module(\\n _template_jet_collection_name + suffix,\\n getattr(process, _template_jet_collection_name).clone(\\n **jet_kwargs\\n )\\n )\\n process.add_module(\\n _template_met_collection_name + suffix,\\n getattr(process, _template_met_collection_name).clone(\\n # jets for type-I correction\\n karmaCorrectedJetCollectionSrc=cms.InputTag(\\n _template_jet_collection_name + suffix\\n ),\\n )\\n )\\n\\n for _template_map_name in _template_map_names:\\n process.add_module(\\n _template_map_name + suffix,\\n getattr(process, _template_map_name).clone(\\n primaryCollectionSrc=cms.InputTag(_template_jet_collection_name + suffix),\\n )\\n )\\n\\n if options.isData:\\n # data-only\\n\\n # -- prefiring Weights\\n _template_prefiring_weights_name = \\\"{}PrefiringWeights{}\\\".format(prefix, jet_algo_name)\\n process.add_module(\\n _template_prefiring_weights_name + suffix,\\n getattr(process, _template_prefiring_weights_name).clone(\\n karmaJetCollectionSrc = cms.InputTag(_template_jet_collection_name + suffix),\\n )\\n )\\n else:\\n # mc-only\\n\\n # -- jet-genjet maps\\n _template_genjet_map_name = \\\"{}JetGenJetMap{}\\\".format(prefix, jet_algo_name)\\n process.add_module(\\n _template_genjet_map_name + suffix,\\n getattr(process, _template_genjet_map_name).clone(\\n primaryCollectionSrc=cms.InputTag(_template_jet_collection_name + suffix),\\n secondaryCollectionSrc=cms.InputTag(\\\"karmaGenJets{}\\\".format(jet_algo_name[:3])),\\n maxDeltaR=cms.double(0.4 if 'AK8' in jet_algo_name else 0.2)\\n )\\n )\",\n \"def build_modules(self):\\n self.backbone = Backbone(\\n self.configs['backbone'],\\n freeze_backbone=self.configs['freeze_backbone'],\\n freeze_batchnorm=True\\n )\\n\\n backbone_channel_sizes = get_backbone_channel_sizes(self.backbone)\\n\\n self.fpn = FeaturePyramidNetwork(\\n backbone_channel_sizes=backbone_channel_sizes,\\n min_feature_level=self.configs['min_feature_level'],\\n max_feature_level=self.configs['max_feature_level'],\\n feature_size=self.configs['pyramid_feature_size']\\n )\\n\\n self.shared_conv_model = SharedConvModel(\\n input_feature_size=self.configs['pyramid_feature_size'],\\n feature_size=self.configs['shared_conv_feature_size'],\\n num_layers=self.configs['shared_conv_num_layers']\\n )\\n\\n if self.configs['shared_conv_num_layers'] > 0:\\n shared_conv_output_size = self.configs['shared_conv_feature_size']\\n else:\\n shared_conv_output_size = self.configs['pyramid_feature_size']\\n\\n self.ofn = ObjectFinderNetwork(\\n input_feature_size=shared_conv_output_size,\\n feature_size=self.configs['finder_feature_size'],\\n num_layers=self.configs['finder_num_layers']\\n )\\n\\n self.ofn_loss_fn\\n\\n # self.classification_model = ClassificationModel()\\n #\\n # self.regression_model = RegressionModel()\",\n \"def initialize(self):\\n\\n # create plugin locations\\n for p in (cache_path, config_path, data_path):\\n p.mkdir(parents=False, exist_ok=True)\",\n \"def create_files(project_name, root_dir):\\r\\n root_dir = projectfolders.create_path(root_dir, project_name) #Modify the root\\r\\n \\r\\n write_setup(project_name, root_dir)\\r\\n write_inits(project_name, root_dir)\\r\\n write_tests(project_name, root_dir)\",\n \"def _configure_libraries():\\n # An environment option to disable `import cv2` globally,\\n # in case it leads to negative performance impact\\n disable_cv2 = int(os.environ.get(\\\"DETECTRON2_DISABLE_CV2\\\", False))\\n if disable_cv2:\\n sys.modules[\\\"cv2\\\"] = None\\n else:\\n # Disable opencl in opencv since its interaction with cuda often has negative effects\\n # This envvar is supported after OpenCV 3.4.0\\n os.environ[\\\"OPENCV_OPENCL_RUNTIME\\\"] = \\\"disabled\\\"\\n try:\\n import cv2\\n\\n if int(cv2.__version__.split(\\\".\\\")[0]) >= 3:\\n cv2.ocl.setUseOpenCL(False)\\n except ModuleNotFoundError:\\n # Other types of ImportError, if happened, should not be ignored.\\n # Because a failed opencv import could mess up address space\\n # https://github.com/skvark/opencv-python/issues/381\\n pass\\n\\n def get_version(module, digit=2):\\n return tuple(map(int, module.__version__.split(\\\".\\\")[:digit]))\\n\\n # fmt: off\\n assert get_version(torch) >= (1, 4), \\\"Requires torch>=1.4\\\"\\n import fvcore\\n assert get_version(fvcore, 3) >= (0, 1, 2), \\\"Requires fvcore>=0.1.2\\\"\\n import yaml\\n assert get_version(yaml) >= (5, 1), \\\"Requires pyyaml>=5.1\\\"\\n # fmt: on\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6650628","0.61216825","0.59788126","0.5914733","0.5853105","0.5761492","0.5729343","0.57070595","0.5634071","0.5578847","0.5557914","0.55127","0.5486333","0.5457092","0.5417137","0.54008245","0.5397091","0.53696746","0.53682125","0.5365185","0.53581166","0.53523415","0.5310362","0.5295752","0.5293841","0.52729946","0.52695954","0.5262353","0.52619714","0.52426034","0.52318627","0.52307147","0.52214676","0.52207196","0.52173173","0.51990324","0.51907647","0.5180949","0.5174759","0.5172353","0.5144277","0.514036","0.5136478","0.51306117","0.51250196","0.5123664","0.51155704","0.51119584","0.5111413","0.51107365","0.510737","0.5105754","0.50968367","0.5095345","0.50913936","0.50888246","0.5088401","0.5077897","0.5062594","0.5060975","0.50575304","0.50575304","0.5052717","0.50510705","0.5043331","0.5038227","0.5036745","0.5033657","0.50330806","0.50263095","0.50242347","0.50229466","0.5019969","0.50182647","0.50169","0.5009988","0.50085866","0.4993016","0.49847728","0.49794042","0.49725145","0.49711594","0.49648356","0.4957816","0.4942972","0.49389014","0.49305502","0.49269038","0.492517","0.4920447","0.49196625","0.4918269","0.49165988","0.49102247","0.49095607","0.49062008","0.48931018","0.48930904","0.4888881","0.48874828"],"string":"[\n \"0.6650628\",\n \"0.61216825\",\n \"0.59788126\",\n \"0.5914733\",\n \"0.5853105\",\n \"0.5761492\",\n \"0.5729343\",\n \"0.57070595\",\n \"0.5634071\",\n \"0.5578847\",\n \"0.5557914\",\n \"0.55127\",\n \"0.5486333\",\n \"0.5457092\",\n \"0.5417137\",\n \"0.54008245\",\n \"0.5397091\",\n \"0.53696746\",\n \"0.53682125\",\n \"0.5365185\",\n \"0.53581166\",\n \"0.53523415\",\n \"0.5310362\",\n \"0.5295752\",\n \"0.5293841\",\n \"0.52729946\",\n \"0.52695954\",\n \"0.5262353\",\n \"0.52619714\",\n \"0.52426034\",\n \"0.52318627\",\n \"0.52307147\",\n \"0.52214676\",\n \"0.52207196\",\n \"0.52173173\",\n \"0.51990324\",\n \"0.51907647\",\n \"0.5180949\",\n \"0.5174759\",\n \"0.5172353\",\n \"0.5144277\",\n \"0.514036\",\n \"0.5136478\",\n \"0.51306117\",\n \"0.51250196\",\n \"0.5123664\",\n \"0.51155704\",\n \"0.51119584\",\n \"0.5111413\",\n \"0.51107365\",\n \"0.510737\",\n \"0.5105754\",\n \"0.50968367\",\n \"0.5095345\",\n \"0.50913936\",\n \"0.50888246\",\n \"0.5088401\",\n \"0.5077897\",\n \"0.5062594\",\n \"0.5060975\",\n \"0.50575304\",\n \"0.50575304\",\n \"0.5052717\",\n \"0.50510705\",\n \"0.5043331\",\n \"0.5038227\",\n \"0.5036745\",\n \"0.5033657\",\n \"0.50330806\",\n \"0.50263095\",\n \"0.50242347\",\n \"0.50229466\",\n \"0.5019969\",\n \"0.50182647\",\n \"0.50169\",\n \"0.5009988\",\n \"0.50085866\",\n \"0.4993016\",\n \"0.49847728\",\n \"0.49794042\",\n \"0.49725145\",\n \"0.49711594\",\n \"0.49648356\",\n \"0.4957816\",\n \"0.4942972\",\n \"0.49389014\",\n \"0.49305502\",\n \"0.49269038\",\n \"0.492517\",\n \"0.4920447\",\n \"0.49196625\",\n \"0.4918269\",\n \"0.49165988\",\n \"0.49102247\",\n \"0.49095607\",\n \"0.49062008\",\n \"0.48931018\",\n \"0.48930904\",\n \"0.4888881\",\n \"0.48874828\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7787591"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":12876,"cells":{"query":{"kind":"string","value":"A new hash string should be 152 bytes long"},"document":{"kind":"string","value":"def test_new(self):\n self.assertEqual(len(p.new('foo')), 168)"},"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_hash(self, long_url: str, hash_length: int):\n hasher = hashlib.md5(long_url.encode())\n bytes_hash = base64.urlsafe_b64encode(hasher.digest())[:hash_length]\n str_hash = bytes_hash.decode()\n return str_hash","def hash(plainString):\n result = plainString\n for i in range(0,12):\n result = hashHelp(result)\n return result","def hash_str_length(self):\n return self.hash_byte_length() * 2","def apply_hash (self, s):\r\n m = md5()\r\n m.update (s)\r\n d = m.digest()\r\n # base64.encodestring tacks on an extra linefeed.\r\n return encodestring (d)[:-1]","def create_hash() -> str:\n length = 6\n char = string.ascii_uppercase + string.digits + string.ascii_lowercase\n\n # Generate a new ID, until one is found that is unique\n while True:\n hash = \"\".join(random.choice(char) for _ in range(length))\n\n if not utils.cache_is_hash_taken(hash):\n return hash","def hash(self) -> str:\r\n ...","def hash_str(c, hash_length):\n if isinstance(c, float):\n if numpy.isnan(c):\n return c\n raise ValueError(f\"numpy.nan expected, not {c}\")\n m = hashlib.sha256()\n m.update(c.encode(\"utf-8\"))\n r = m.hexdigest()\n if len(r) >= hash_length:\n return r[:hash_length]\n return r","def getHash():\n return str(uuid.uuid4())[-17:].replace(\"-\", \"\")","def gen_hash(s: str) -> str:\n\n m = hashlib.md5()\n m.update(bytes(s, encoding = 'utf8'))\n hash_code = str(m.hexdigest())\n\n return hash_code","def strhash(s: str) -> int:\n h = hashlib.md5(s.encode('utf-8'))\n h = int(h.hexdigest(), base=16)\n return h","def hash_string(to_hash):\n\n chars = string.printable\n\n hashed = \"\"\n\n total = 1\n\n counter = 1\n\n for letter in to_hash:\n\n total *= (chars.index(letter) * counter * len(to_hash)*13)\n\n counter += 1\n\n if counter%3 == 0:\n\n total *= total\n\n total = str(total)[:30]\n\n temp_int = \"\"\n\n for i in range(len(total)):\n\n temp_int += total[i]\n\n if i % 2 != 0:\n\n hashed += chars[int(temp_int)]\n\n temp_int = \"\"\n\n return hashed","def hash(self) -> bytes:","def computeHash(string):\n\tif isBytes(string):\n\t\tstring = string.decode(\"latin-1\")\n\thash_ = 63689\n\tfor char in string:\n\t\thash_ = hash_ * 378551 + ord(char)\n\treturn hash_ % 65536","def get_hash_code(s):\n h = 0\n n = len(s)\n for i, c in enumerate(s):\n h = h + ord(c) * 31 ** (n - 1 - i)\n return StrUtil.convert_4_bytes(h)","def __polynomial_hash(self, s, base = 31, max_size=168):\r\n digest = 0\r\n max_size = 168\r\n for c in s: digest = base * digest + ord(c)\r\n digest &= 2 ** max_size - 1 \r\n return hex(digest).rstrip('L')","def hashing(word) :\r\n ans = hashlib.sha256(word.encode())\r\n return ans.hexdigest()","def create_hash(self):\n return os.urandom(32).encode('hex')","def get_256_hash_from_string(string):\n\n sha256 = hashlib.sha256()\n sha256.update(string.encode('utf-8'))\n\n return sha256.hexdigest()","def _hash(self, key):\n\n return long(hashlib.md5(key).hexdigest(), 16)","def _hash(self, key):\n\n return long(hashlib.md5(key).hexdigest(), 16)","def chord_hash(input_string):\n h = hashlib.sha1() # 160 bit string\n encoded_data = input_string.encode('utf-8')\n h.update(encoded_data)\n hex_string = h.hexdigest()\n hex_value = int(hex_string, 16)\n hash_integer_value = hex_value >> (160 - m)\n return hash_integer_value","def HexDigest(self, name, truncation_length=None):\n\n if truncation_length is None:\n truncation_length = 64\n name_bytes = name.encode('UTF-8')\n return hashlib.sha256(name_bytes).hexdigest()[:truncation_length]","def str_sha(raw_sha):\n return hexlify(raw_sha)[:12]","def hashhex(s):\n h = hashlib.sha1()\n h.update(s.encode('utf-8'))\n return h.hexdigest()","def _hash_name(self, name, length=None):\n if not length:\n length = self.header_size\n hashed = name[:min(length, len(name))]\n for x in range(length, len(name), length):\n rem = min(x+length,len(name))-x\n for i in range(rem):\n hashed = hashed[:i] + chr(ord(name[x + i]) ^ ord(hashed[i])) + hashed[i+1:]\n if len(hashed) < length:\n hashed += '\\x00' * (length-len(hashed))\n return hashed","def hashhex(s):\n h = hashlib.sha1()\n h.update(s)\n return h.hexdigest()","def customHashFunc(str):\n return sum(ord(chr) for chr in str)%128","def calc_statistics_hash(self) -> bytes:\n return b\"somehash\"","def hash_with_salt(self, s):\n\n data = f'{s} {self.salt}'.encode('ascii') # encode string to raw bytes object\n hash_obj = hashlib.md5(data) # hash it \n if self.trunc > 0:\n hash_txt = hash_obj.hexdigest()[0:self.trunc] # get truncated hash symbols\n else:\n hash_txt = hash_obj.hexdigest()\n return f'{s} {hash_txt}'","def hashhex(s):\n h = hashlib.sha1()\n h.update(s.encode())\n return h.hexdigest()","def hashhex(s):\n h = hashlib.sha1()\n h.update(s.encode('utf-8'))\n return h.hexdigest()","def sha256_hexoutput(in_str):\r\n return sha256(in_str.encode('ascii')).hexdigest()","def smallHash(number, text):\n m = hashlib.md5()\n m.update(bytes(number))\n m.update(text.encode('utf-8'))\n return int(m.hexdigest(), 16) % 1000000","def _Hash(content: bytes) -> str:\n return hashlib.sha256(content).hexdigest()","def get_hash_str():\r\n\tli = \"\"\r\n\tfor i in range(5):\r\n\t\tli += str(int(int((6 * random.random()) + 1)))\r\n\treturn li","def get_hash(s):\n hash_object = hashlib.md5(s.encode())\n return hash_object.hexdigest()","def hex_hash(s):\n if not s:\n return '0'\n s = s.encode('utf-8')\n return '{:x}'.format(adler32(s) & 0xffffffff)","def hash_password(password):\n\n return hashlib.sha224(password).hexdigest()[:20]","def hash_me(cls, p_str, p_len=64):\n v_hash = str()\n v_len = EC.SHA256 if p_len is None else EC.SHA256 if p_len not in EC.HASH_ALGO else p_len\n if v_len == EC.SHA512:\n v_hash = hashlib.sha512()\n elif v_len == EC.SHA256:\n v_hash = hashlib.sha256()\n elif v_len == EC.SHA224:\n v_hash = hashlib.sha224()\n elif v_len == EC.SHA1:\n v_hash = hashlib.sha1()\n\n v_hash.update(p_str.encode(\"utf-8\"))\n return v_hash.hexdigest()","def default_hash():\n return \"!\"","def _Hash(self):\n fullhash = util.Hash(util.IntToBytes(len(self.key_bytes)), self.key_bytes)\n return util.Encode(fullhash[:keyczar.KEY_HASH_SIZE])","def hash_key(self, key):\r\n hashed_key = sum((ord(char) for char in key))\r\n return hashed_key % 20","def hashing_info(string):#KEY HASHING FUNCTION\n nodeInfo = string.encode('utf-8')\n\n #md5 -> 2^7 = 128 bits\n hash_object = hashlib.md5()\n hash_object.update(nodeInfo)\n\n tmp = hash_object.hexdigest()\n tmp = int(tmp,16)\n\n result = tmp >> (128-16)\n return result","def generateHash(*length):\n from string import letters, digits\n from random import choice\n pool, size = letters + digits, length or 10\n hash = ''.join([choice(pool) for i in range(size)])\n return hash.lower()","def _calculate_hash(self) -> str:\n data_str = str(self.version) + str(self.index) + self.pre_hash + str(self.timestamp) + str(self.data)\n return sha256(data_str.encode('utf-8')).hexdigest()","def keyhash(string):\n return hashlib.sha1(string.encode('utf-8')).hexdigest()","def sha256_2_string(string_to_hash):\n\n # Solution for (1a)\n import hashlib\n first_sha = hashlib.sha256(string_to_hash.encode(\"utf8\"))\n second_sha = hashlib.sha256(first_sha.digest())\n return second_sha.hexdigest()\n\n # Placeholder for (1a)\n return \"deadbeef\"","def short_hash(hash, chars=11):\n ch_ea = int((chars - 3) / 2)\n if hash is None:\n return (\"0\" * ch_ea) + \"...\" + (\"0\" * ch_ea)\n return hash[:ch_ea] + \"...\" + hash[(-1 * ch_ea):]","def fasthash(string):\r\n md4 = hashlib.new(\"md4\")\r\n md4.update(string)\r\n return md4.hexdigest()","def _hash_value(value):\n return hashlib.md5(value.encode('utf-8')).hexdigest()[:9]","def hash_bytes_256(b: bytes) -> str:\n return hashlib.sha256(b).hexdigest()","def hash_cli_name(name):\n from hashlib import blake2b\n return blake2b(name.encode(), digest_size=32).hexdigest()","def _Hash(self):\n fullhash = util.PrefixHash(self.key_bytes)\n return util.Base64WSEncode(fullhash[:constants.KEY_HASH_SIZE])","def hash(self, string):\n return self.__scaffydb.hash(string)","def get_binary_sha256_hash(hash: str) -> str:\n result = \"\"\n\n for character in hash:\n character_number = int(character, base=16)\n binary_number = bin(character_number)\n # CAVEAT: each hash character is 4 bit size since SHA256 hash is hexidecimal string, so 4 * 64 = 256 bit\n formatted_binary_number = binary_number[2:].ljust(4, \"0\")\n result += formatted_binary_number\n\n return result","def hashHelp(plainString):\n # hashed = plainString\n n = len(plainString) // 4\n\n a = plainString[0:n]\n b = plainString[n : n * 2]\n c = plainString[n * 2 : n * 3]\n d = plainString[n * 3 : len(plainString)]\n\n if len(a) == 0 or len(b) == 0 or len(c) == 0 or len(d) == 0:\n raise Exception(\"Error string not long enough, use at least 4 characters\")\n\n numA = numToBin(functionF(a,d))\n numB = numToBin(strToNum(b))\n numC = numToBin(bitShift(c))\n numD = numToBin(functionG(a,b,c,d))\n\n # hashed = A + B + numC + D\n # hashed = numA + '|' + numB + '|' + numC + '|' + numD\n hashed = text_from_bits(numD + numA + numB + numC)\n hashed = numbersToLetters(hashed)\n return hashed","def seed_hash(*args):\n args_str = str(args)\n return int(hashlib.md5(args_str.encode(\"utf-8\")).hexdigest(), 16) % (2**31)","def HashAlgorithm(self) -> _n_7_t_0:","def hash(self, string):\n h = md5()\n h.update(string)\n return h.digest()","def get_hash(link):\n return hashlib.sha256(link.encode('utf-8')).hexdigest()","def knot_hash(s: str) -> str:\n inp = [ord(c) for c in s] + [17, 31, 73, 47, 23]\n seq = [*range(256)]\n skip, pos = 0, 0\n for _ in range(64):\n seq, skip, pos = knot_hash_round(inp, seq, skip, pos, in_place=False)\n seq = [reduce(lambda a, b: a ^ b, seq[i:i + 16]) for i in range(0, 256, 16)]\n return ''.join(hex(k)[2:].zfill(2) for k in seq)","def h(x):\n\n hasher = hashlib.sha256()\n hasher.update(x)\n return hasher.digest()","def hash_function(s):\n\n # O(n) over the key length\n # O(1) over the HASH_DATA_SIZE\n\n bytes_list = s.encode()\n\n total = 0\n\n\n for b in bytes_list: # O(n) over the length of the key\n total += b\n\n\n total &= 0xffffffff # 32 bit (8 f's)\n\n return total","def _hash(self, string, hash_type):\n hash_types = {\n 'TABLE_OFFSET': 0,\n 'HASH_A': 1,\n 'HASH_B': 2,\n 'TABLE': 3\n }\n seed1 = 0x7FED7FED\n seed2 = 0xEEEEEEEE\n\n for ch in string.upper():\n if not isinstance(ch, int): ch = ord(ch)\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\n\n return seed1","def sha256(s: str) -> str:\n return hashlib.sha256(s.encode()).hexdigest()","def b64hash(s):\n _hash = hashlib.sha256()\n _hash.update(str2bytes(s))\n return bytes2str(b64encode(_hash.digest()))","def hash_password(password):\n password_md5 = hashlib.md5(password.encode('utf-8')).hexdigest()\n for i in range(0, len(password_md5), 2):\n if password_md5[i] == '0':\n password_md5 = password_md5[0:i] + 'c' + password_md5[i + 1:]\n return password_md5","def elf_hash(s):\n h = 0\n for c in s:\n h = (h << 4) + ord(c)\n t = (h & 0xF0000000)\n if t != 0:\n h = h ^ (t >> 24)\n h = h & ~t\n return h","def hash_128_bit_pass(passwd):\n h = hashlib.sha256()\n h.update(passwd)\n return h.hexdigest()[:16]","def SHA256(self) -> _n_0_t_3[_n_0_t_9]:","def __hash_md5__(self, text):\n key = hashlib.md5()\n key.update(text.encode('utf-8'))\n return key.digest()","def _electrum_script_hash(script: bytes) -> str:\n bytes = bytearray(scripts.sha256(script))\n bytes.reverse()\n return bytes.hex()","def test_hash_url(self):\r\n url = u'http://google.com'\r\n hashed = generate_hash(url)\r\n self.assertEqual('aa2239c17609b2', hashed)","def trim_hash(info_hash):\n if len(info_hash) == 40:\n return info_hash.decode(\"hex\")\n if len(info_hash) != 20:\n raise TrackerRequestException(\"Infohash not equal to 20 digits\", info_hash)\n return info_hash","def hash(self, text):\n hashval = 0\n for i in xrange(0, len(text)):\n hashval += ord(text[i])**i\n return hashval","def hashPassword(passwd):\r\n \r\n return hashlib.sha224(passwd).hexdigest()","def b32hash(s):\n _hash = hashlib.sha256()\n _hash.update(str2bytes(s))\n return bytes2str(b32encode(_hash.digest()))","def _hash_content(data):\n return hashlib.sha512(str(data).encode('utf-8')).hexdigest()","def hash_string(input_str):\n input_b = str.encode(input_str)\n input_hash = hashlib.md5(input_b.lower())\n input_hash_str = input_hash.hexdigest()\n\n return input_hash_str","def __str_to_hash(string_to_hash: str, errors: str = 'ignore') -> str:\n string_hash = string_to_hash.encode(encoding=\"utf-8\", errors=errors)\n return hashlib.md5(string_hash).hexdigest()","def _sha256(sha256):\n if not sha256:\n sha256 = \"0\" * 64\n\n return sha256","def hashLink(link):\n\n return str(md5.new(link).hexdigest())[:5]","def hash_string(\r\n k: bytes,\r\n e: str,\r\n) -> bytes:\r\n return hmac.new(k, e.encode('utf-8'), hashlib.sha256).digest()","def dopplr(name):\n return \"#\" + hashlib.sha224(name).hexdigest()[:6]","def typeahead_hash(self) -> str:","def hashstring(astring, tablesize):\n \n sum = 0\n for pos in range(len(astring)):\n # to account for anagrams, we give weightage to positions of the letters to give different hash values\n sum = sum + ord(astring[pos]) * (pos + 1)\n \n return sum % tablesize","def hash(string):\n hs = 0\n for s in string:\n hs += ord(s)\n return hs","def badhash(x):\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\n x = ((x >> 16) ^ x) & 0xFFFFFFFF\n return x","def hash_string(self):\n return self._hash_string","def SHA1(self) -> _n_0_t_3[_n_0_t_9]:","def test_hash_string(self):\n self.assertEqual(hexlify(self._hashdigest(pubkey_sha)), sample_ripe)","def hash_str(string):\n\n return hmac.new(secret, string).hexdigest()","def hash_string(password):\n return hash(password)","def digest(self, message):\n\n hasher = hashlib.md5()\n hasher.update(message)\n digest = hasher.digest()[0:self.HASHLEN]\n\n return binascii.hexlify(digest)","def count_md5hash_bytes(byte_flow):\n hash_md5 = hashlib.md5()\n hash_md5.update(byte_flow)\n return hash_md5.hexdigest()","def calculateHash(self):\n hashData = str(self.index) + str(self.data) + self.timestamp + self.previousHash + str(self.nonce)\n return hashlib.sha256(hashData.encode(encoding='UTF-8',errors='strict')).hexdigest()","def sdbm_hash(name):\n ret = 0\n for ii in name:\n ret = (ret * 65599 + ord(ii)) & 0xFFFFFFFF\n return hex(ret)","def get_file_hash(fname, hash_length):\n hash_sha = hashlib.sha256()\n with open(fname, 'rb') as infile:\n for chunk in iter(lambda: infile.read(4096), b''):\n hash_sha.update(chunk)\n hash_sha = hash_sha.hexdigest()\n hash_sha = int(hash_sha, 16) % (2 ** (4 * hash_length))\n return hex_encode(hash_sha, hash_length)","def __hash__(self):\n token = \"\"\n for gamePiece in self.game_pieces:\n token = token + str(gamePiece.x) + str(gamePiece.y)\n \n hash_ = int(token) % 100000\n return hash_","def fnv1(self, key):\n # hash = 0xff\n hash = 0xcbf29ce484222325\n for n in key.encode():\n # print(n)\n hash = hash ^ n\n hash = hash * 0x100000001b3\n\n # print(hash)\n return hash","def myHash(string, base=91, mod=1000000321):\n value = 0\n for pos, elem in enumerate(string[::-1]): # считаем значение полинома\n value += ord(elem) * base**pos # в последней задаче сделано с помощью массива (динамика)\n return value % mod"],"string":"[\n \"def make_hash(self, long_url: str, hash_length: int):\\n hasher = hashlib.md5(long_url.encode())\\n bytes_hash = base64.urlsafe_b64encode(hasher.digest())[:hash_length]\\n str_hash = bytes_hash.decode()\\n return str_hash\",\n \"def hash(plainString):\\n result = plainString\\n for i in range(0,12):\\n result = hashHelp(result)\\n return result\",\n \"def hash_str_length(self):\\n return self.hash_byte_length() * 2\",\n \"def apply_hash (self, s):\\r\\n m = md5()\\r\\n m.update (s)\\r\\n d = m.digest()\\r\\n # base64.encodestring tacks on an extra linefeed.\\r\\n return encodestring (d)[:-1]\",\n \"def create_hash() -> str:\\n length = 6\\n char = string.ascii_uppercase + string.digits + string.ascii_lowercase\\n\\n # Generate a new ID, until one is found that is unique\\n while True:\\n hash = \\\"\\\".join(random.choice(char) for _ in range(length))\\n\\n if not utils.cache_is_hash_taken(hash):\\n return hash\",\n \"def hash(self) -> str:\\r\\n ...\",\n \"def hash_str(c, hash_length):\\n if isinstance(c, float):\\n if numpy.isnan(c):\\n return c\\n raise ValueError(f\\\"numpy.nan expected, not {c}\\\")\\n m = hashlib.sha256()\\n m.update(c.encode(\\\"utf-8\\\"))\\n r = m.hexdigest()\\n if len(r) >= hash_length:\\n return r[:hash_length]\\n return r\",\n \"def getHash():\\n return str(uuid.uuid4())[-17:].replace(\\\"-\\\", \\\"\\\")\",\n \"def gen_hash(s: str) -> str:\\n\\n m = hashlib.md5()\\n m.update(bytes(s, encoding = 'utf8'))\\n hash_code = str(m.hexdigest())\\n\\n return hash_code\",\n \"def strhash(s: str) -> int:\\n h = hashlib.md5(s.encode('utf-8'))\\n h = int(h.hexdigest(), base=16)\\n return h\",\n \"def hash_string(to_hash):\\n\\n chars = string.printable\\n\\n hashed = \\\"\\\"\\n\\n total = 1\\n\\n counter = 1\\n\\n for letter in to_hash:\\n\\n total *= (chars.index(letter) * counter * len(to_hash)*13)\\n\\n counter += 1\\n\\n if counter%3 == 0:\\n\\n total *= total\\n\\n total = str(total)[:30]\\n\\n temp_int = \\\"\\\"\\n\\n for i in range(len(total)):\\n\\n temp_int += total[i]\\n\\n if i % 2 != 0:\\n\\n hashed += chars[int(temp_int)]\\n\\n temp_int = \\\"\\\"\\n\\n return hashed\",\n \"def hash(self) -> bytes:\",\n \"def computeHash(string):\\n\\tif isBytes(string):\\n\\t\\tstring = string.decode(\\\"latin-1\\\")\\n\\thash_ = 63689\\n\\tfor char in string:\\n\\t\\thash_ = hash_ * 378551 + ord(char)\\n\\treturn hash_ % 65536\",\n \"def get_hash_code(s):\\n h = 0\\n n = len(s)\\n for i, c in enumerate(s):\\n h = h + ord(c) * 31 ** (n - 1 - i)\\n return StrUtil.convert_4_bytes(h)\",\n \"def __polynomial_hash(self, s, base = 31, max_size=168):\\r\\n digest = 0\\r\\n max_size = 168\\r\\n for c in s: digest = base * digest + ord(c)\\r\\n digest &= 2 ** max_size - 1 \\r\\n return hex(digest).rstrip('L')\",\n \"def hashing(word) :\\r\\n ans = hashlib.sha256(word.encode())\\r\\n return ans.hexdigest()\",\n \"def create_hash(self):\\n return os.urandom(32).encode('hex')\",\n \"def get_256_hash_from_string(string):\\n\\n sha256 = hashlib.sha256()\\n sha256.update(string.encode('utf-8'))\\n\\n return sha256.hexdigest()\",\n \"def _hash(self, key):\\n\\n return long(hashlib.md5(key).hexdigest(), 16)\",\n \"def _hash(self, key):\\n\\n return long(hashlib.md5(key).hexdigest(), 16)\",\n \"def chord_hash(input_string):\\n h = hashlib.sha1() # 160 bit string\\n encoded_data = input_string.encode('utf-8')\\n h.update(encoded_data)\\n hex_string = h.hexdigest()\\n hex_value = int(hex_string, 16)\\n hash_integer_value = hex_value >> (160 - m)\\n return hash_integer_value\",\n \"def HexDigest(self, name, truncation_length=None):\\n\\n if truncation_length is None:\\n truncation_length = 64\\n name_bytes = name.encode('UTF-8')\\n return hashlib.sha256(name_bytes).hexdigest()[:truncation_length]\",\n \"def str_sha(raw_sha):\\n return hexlify(raw_sha)[:12]\",\n \"def hashhex(s):\\n h = hashlib.sha1()\\n h.update(s.encode('utf-8'))\\n return h.hexdigest()\",\n \"def _hash_name(self, name, length=None):\\n if not length:\\n length = self.header_size\\n hashed = name[:min(length, len(name))]\\n for x in range(length, len(name), length):\\n rem = min(x+length,len(name))-x\\n for i in range(rem):\\n hashed = hashed[:i] + chr(ord(name[x + i]) ^ ord(hashed[i])) + hashed[i+1:]\\n if len(hashed) < length:\\n hashed += '\\\\x00' * (length-len(hashed))\\n return hashed\",\n \"def hashhex(s):\\n h = hashlib.sha1()\\n h.update(s)\\n return h.hexdigest()\",\n \"def customHashFunc(str):\\n return sum(ord(chr) for chr in str)%128\",\n \"def calc_statistics_hash(self) -> bytes:\\n return b\\\"somehash\\\"\",\n \"def hash_with_salt(self, s):\\n\\n data = f'{s} {self.salt}'.encode('ascii') # encode string to raw bytes object\\n hash_obj = hashlib.md5(data) # hash it \\n if self.trunc > 0:\\n hash_txt = hash_obj.hexdigest()[0:self.trunc] # get truncated hash symbols\\n else:\\n hash_txt = hash_obj.hexdigest()\\n return f'{s} {hash_txt}'\",\n \"def hashhex(s):\\n h = hashlib.sha1()\\n h.update(s.encode())\\n return h.hexdigest()\",\n \"def hashhex(s):\\n h = hashlib.sha1()\\n h.update(s.encode('utf-8'))\\n return h.hexdigest()\",\n \"def sha256_hexoutput(in_str):\\r\\n return sha256(in_str.encode('ascii')).hexdigest()\",\n \"def smallHash(number, text):\\n m = hashlib.md5()\\n m.update(bytes(number))\\n m.update(text.encode('utf-8'))\\n return int(m.hexdigest(), 16) % 1000000\",\n \"def _Hash(content: bytes) -> str:\\n return hashlib.sha256(content).hexdigest()\",\n \"def get_hash_str():\\r\\n\\tli = \\\"\\\"\\r\\n\\tfor i in range(5):\\r\\n\\t\\tli += str(int(int((6 * random.random()) + 1)))\\r\\n\\treturn li\",\n \"def get_hash(s):\\n hash_object = hashlib.md5(s.encode())\\n return hash_object.hexdigest()\",\n \"def hex_hash(s):\\n if not s:\\n return '0'\\n s = s.encode('utf-8')\\n return '{:x}'.format(adler32(s) & 0xffffffff)\",\n \"def hash_password(password):\\n\\n return hashlib.sha224(password).hexdigest()[:20]\",\n \"def hash_me(cls, p_str, p_len=64):\\n v_hash = str()\\n v_len = EC.SHA256 if p_len is None else EC.SHA256 if p_len not in EC.HASH_ALGO else p_len\\n if v_len == EC.SHA512:\\n v_hash = hashlib.sha512()\\n elif v_len == EC.SHA256:\\n v_hash = hashlib.sha256()\\n elif v_len == EC.SHA224:\\n v_hash = hashlib.sha224()\\n elif v_len == EC.SHA1:\\n v_hash = hashlib.sha1()\\n\\n v_hash.update(p_str.encode(\\\"utf-8\\\"))\\n return v_hash.hexdigest()\",\n \"def default_hash():\\n return \\\"!\\\"\",\n \"def _Hash(self):\\n fullhash = util.Hash(util.IntToBytes(len(self.key_bytes)), self.key_bytes)\\n return util.Encode(fullhash[:keyczar.KEY_HASH_SIZE])\",\n \"def hash_key(self, key):\\r\\n hashed_key = sum((ord(char) for char in key))\\r\\n return hashed_key % 20\",\n \"def hashing_info(string):#KEY HASHING FUNCTION\\n nodeInfo = string.encode('utf-8')\\n\\n #md5 -> 2^7 = 128 bits\\n hash_object = hashlib.md5()\\n hash_object.update(nodeInfo)\\n\\n tmp = hash_object.hexdigest()\\n tmp = int(tmp,16)\\n\\n result = tmp >> (128-16)\\n return result\",\n \"def generateHash(*length):\\n from string import letters, digits\\n from random import choice\\n pool, size = letters + digits, length or 10\\n hash = ''.join([choice(pool) for i in range(size)])\\n return hash.lower()\",\n \"def _calculate_hash(self) -> str:\\n data_str = str(self.version) + str(self.index) + self.pre_hash + str(self.timestamp) + str(self.data)\\n return sha256(data_str.encode('utf-8')).hexdigest()\",\n \"def keyhash(string):\\n return hashlib.sha1(string.encode('utf-8')).hexdigest()\",\n \"def sha256_2_string(string_to_hash):\\n\\n # Solution for (1a)\\n import hashlib\\n first_sha = hashlib.sha256(string_to_hash.encode(\\\"utf8\\\"))\\n second_sha = hashlib.sha256(first_sha.digest())\\n return second_sha.hexdigest()\\n\\n # Placeholder for (1a)\\n return \\\"deadbeef\\\"\",\n \"def short_hash(hash, chars=11):\\n ch_ea = int((chars - 3) / 2)\\n if hash is None:\\n return (\\\"0\\\" * ch_ea) + \\\"...\\\" + (\\\"0\\\" * ch_ea)\\n return hash[:ch_ea] + \\\"...\\\" + hash[(-1 * ch_ea):]\",\n \"def fasthash(string):\\r\\n md4 = hashlib.new(\\\"md4\\\")\\r\\n md4.update(string)\\r\\n return md4.hexdigest()\",\n \"def _hash_value(value):\\n return hashlib.md5(value.encode('utf-8')).hexdigest()[:9]\",\n \"def hash_bytes_256(b: bytes) -> str:\\n return hashlib.sha256(b).hexdigest()\",\n \"def hash_cli_name(name):\\n from hashlib import blake2b\\n return blake2b(name.encode(), digest_size=32).hexdigest()\",\n \"def _Hash(self):\\n fullhash = util.PrefixHash(self.key_bytes)\\n return util.Base64WSEncode(fullhash[:constants.KEY_HASH_SIZE])\",\n \"def hash(self, string):\\n return self.__scaffydb.hash(string)\",\n \"def get_binary_sha256_hash(hash: str) -> str:\\n result = \\\"\\\"\\n\\n for character in hash:\\n character_number = int(character, base=16)\\n binary_number = bin(character_number)\\n # CAVEAT: each hash character is 4 bit size since SHA256 hash is hexidecimal string, so 4 * 64 = 256 bit\\n formatted_binary_number = binary_number[2:].ljust(4, \\\"0\\\")\\n result += formatted_binary_number\\n\\n return result\",\n \"def hashHelp(plainString):\\n # hashed = plainString\\n n = len(plainString) // 4\\n\\n a = plainString[0:n]\\n b = plainString[n : n * 2]\\n c = plainString[n * 2 : n * 3]\\n d = plainString[n * 3 : len(plainString)]\\n\\n if len(a) == 0 or len(b) == 0 or len(c) == 0 or len(d) == 0:\\n raise Exception(\\\"Error string not long enough, use at least 4 characters\\\")\\n\\n numA = numToBin(functionF(a,d))\\n numB = numToBin(strToNum(b))\\n numC = numToBin(bitShift(c))\\n numD = numToBin(functionG(a,b,c,d))\\n\\n # hashed = A + B + numC + D\\n # hashed = numA + '|' + numB + '|' + numC + '|' + numD\\n hashed = text_from_bits(numD + numA + numB + numC)\\n hashed = numbersToLetters(hashed)\\n return hashed\",\n \"def seed_hash(*args):\\n args_str = str(args)\\n return int(hashlib.md5(args_str.encode(\\\"utf-8\\\")).hexdigest(), 16) % (2**31)\",\n \"def HashAlgorithm(self) -> _n_7_t_0:\",\n \"def hash(self, string):\\n h = md5()\\n h.update(string)\\n return h.digest()\",\n \"def get_hash(link):\\n return hashlib.sha256(link.encode('utf-8')).hexdigest()\",\n \"def knot_hash(s: str) -> str:\\n inp = [ord(c) for c in s] + [17, 31, 73, 47, 23]\\n seq = [*range(256)]\\n skip, pos = 0, 0\\n for _ in range(64):\\n seq, skip, pos = knot_hash_round(inp, seq, skip, pos, in_place=False)\\n seq = [reduce(lambda a, b: a ^ b, seq[i:i + 16]) for i in range(0, 256, 16)]\\n return ''.join(hex(k)[2:].zfill(2) for k in seq)\",\n \"def h(x):\\n\\n hasher = hashlib.sha256()\\n hasher.update(x)\\n return hasher.digest()\",\n \"def hash_function(s):\\n\\n # O(n) over the key length\\n # O(1) over the HASH_DATA_SIZE\\n\\n bytes_list = s.encode()\\n\\n total = 0\\n\\n\\n for b in bytes_list: # O(n) over the length of the key\\n total += b\\n\\n\\n total &= 0xffffffff # 32 bit (8 f's)\\n\\n return total\",\n \"def _hash(self, string, hash_type):\\n hash_types = {\\n 'TABLE_OFFSET': 0,\\n 'HASH_A': 1,\\n 'HASH_B': 2,\\n 'TABLE': 3\\n }\\n seed1 = 0x7FED7FED\\n seed2 = 0xEEEEEEEE\\n\\n for ch in string.upper():\\n if not isinstance(ch, int): ch = ord(ch)\\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\\n\\n return seed1\",\n \"def sha256(s: str) -> str:\\n return hashlib.sha256(s.encode()).hexdigest()\",\n \"def b64hash(s):\\n _hash = hashlib.sha256()\\n _hash.update(str2bytes(s))\\n return bytes2str(b64encode(_hash.digest()))\",\n \"def hash_password(password):\\n password_md5 = hashlib.md5(password.encode('utf-8')).hexdigest()\\n for i in range(0, len(password_md5), 2):\\n if password_md5[i] == '0':\\n password_md5 = password_md5[0:i] + 'c' + password_md5[i + 1:]\\n return password_md5\",\n \"def elf_hash(s):\\n h = 0\\n for c in s:\\n h = (h << 4) + ord(c)\\n t = (h & 0xF0000000)\\n if t != 0:\\n h = h ^ (t >> 24)\\n h = h & ~t\\n return h\",\n \"def hash_128_bit_pass(passwd):\\n h = hashlib.sha256()\\n h.update(passwd)\\n return h.hexdigest()[:16]\",\n \"def SHA256(self) -> _n_0_t_3[_n_0_t_9]:\",\n \"def __hash_md5__(self, text):\\n key = hashlib.md5()\\n key.update(text.encode('utf-8'))\\n return key.digest()\",\n \"def _electrum_script_hash(script: bytes) -> str:\\n bytes = bytearray(scripts.sha256(script))\\n bytes.reverse()\\n return bytes.hex()\",\n \"def test_hash_url(self):\\r\\n url = u'http://google.com'\\r\\n hashed = generate_hash(url)\\r\\n self.assertEqual('aa2239c17609b2', hashed)\",\n \"def trim_hash(info_hash):\\n if len(info_hash) == 40:\\n return info_hash.decode(\\\"hex\\\")\\n if len(info_hash) != 20:\\n raise TrackerRequestException(\\\"Infohash not equal to 20 digits\\\", info_hash)\\n return info_hash\",\n \"def hash(self, text):\\n hashval = 0\\n for i in xrange(0, len(text)):\\n hashval += ord(text[i])**i\\n return hashval\",\n \"def hashPassword(passwd):\\r\\n \\r\\n return hashlib.sha224(passwd).hexdigest()\",\n \"def b32hash(s):\\n _hash = hashlib.sha256()\\n _hash.update(str2bytes(s))\\n return bytes2str(b32encode(_hash.digest()))\",\n \"def _hash_content(data):\\n return hashlib.sha512(str(data).encode('utf-8')).hexdigest()\",\n \"def hash_string(input_str):\\n input_b = str.encode(input_str)\\n input_hash = hashlib.md5(input_b.lower())\\n input_hash_str = input_hash.hexdigest()\\n\\n return input_hash_str\",\n \"def __str_to_hash(string_to_hash: str, errors: str = 'ignore') -> str:\\n string_hash = string_to_hash.encode(encoding=\\\"utf-8\\\", errors=errors)\\n return hashlib.md5(string_hash).hexdigest()\",\n \"def _sha256(sha256):\\n if not sha256:\\n sha256 = \\\"0\\\" * 64\\n\\n return sha256\",\n \"def hashLink(link):\\n\\n return str(md5.new(link).hexdigest())[:5]\",\n \"def hash_string(\\r\\n k: bytes,\\r\\n e: str,\\r\\n) -> bytes:\\r\\n return hmac.new(k, e.encode('utf-8'), hashlib.sha256).digest()\",\n \"def dopplr(name):\\n return \\\"#\\\" + hashlib.sha224(name).hexdigest()[:6]\",\n \"def typeahead_hash(self) -> str:\",\n \"def hashstring(astring, tablesize):\\n \\n sum = 0\\n for pos in range(len(astring)):\\n # to account for anagrams, we give weightage to positions of the letters to give different hash values\\n sum = sum + ord(astring[pos]) * (pos + 1)\\n \\n return sum % tablesize\",\n \"def hash(string):\\n hs = 0\\n for s in string:\\n hs += ord(s)\\n return hs\",\n \"def badhash(x):\\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\\n x = (((x >> 16) ^ x) * 0x045d9f3b) & 0xFFFFFFFF\\n x = ((x >> 16) ^ x) & 0xFFFFFFFF\\n return x\",\n \"def hash_string(self):\\n return self._hash_string\",\n \"def SHA1(self) -> _n_0_t_3[_n_0_t_9]:\",\n \"def test_hash_string(self):\\n self.assertEqual(hexlify(self._hashdigest(pubkey_sha)), sample_ripe)\",\n \"def hash_str(string):\\n\\n return hmac.new(secret, string).hexdigest()\",\n \"def hash_string(password):\\n return hash(password)\",\n \"def digest(self, message):\\n\\n hasher = hashlib.md5()\\n hasher.update(message)\\n digest = hasher.digest()[0:self.HASHLEN]\\n\\n return binascii.hexlify(digest)\",\n \"def count_md5hash_bytes(byte_flow):\\n hash_md5 = hashlib.md5()\\n hash_md5.update(byte_flow)\\n return hash_md5.hexdigest()\",\n \"def calculateHash(self):\\n hashData = str(self.index) + str(self.data) + self.timestamp + self.previousHash + str(self.nonce)\\n return hashlib.sha256(hashData.encode(encoding='UTF-8',errors='strict')).hexdigest()\",\n \"def sdbm_hash(name):\\n ret = 0\\n for ii in name:\\n ret = (ret * 65599 + ord(ii)) & 0xFFFFFFFF\\n return hex(ret)\",\n \"def get_file_hash(fname, hash_length):\\n hash_sha = hashlib.sha256()\\n with open(fname, 'rb') as infile:\\n for chunk in iter(lambda: infile.read(4096), b''):\\n hash_sha.update(chunk)\\n hash_sha = hash_sha.hexdigest()\\n hash_sha = int(hash_sha, 16) % (2 ** (4 * hash_length))\\n return hex_encode(hash_sha, hash_length)\",\n \"def __hash__(self):\\n token = \\\"\\\"\\n for gamePiece in self.game_pieces:\\n token = token + str(gamePiece.x) + str(gamePiece.y)\\n \\n hash_ = int(token) % 100000\\n return hash_\",\n \"def fnv1(self, key):\\n # hash = 0xff\\n hash = 0xcbf29ce484222325\\n for n in key.encode():\\n # print(n)\\n hash = hash ^ n\\n hash = hash * 0x100000001b3\\n\\n # print(hash)\\n return hash\",\n \"def myHash(string, base=91, mod=1000000321):\\n value = 0\\n for pos, elem in enumerate(string[::-1]): # считаем значение полинома\\n value += ord(elem) * base**pos # в последней задаче сделано с помощью массива (динамика)\\n return value % mod\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.740472","0.7184337","0.71324676","0.70474213","0.703812","0.70344573","0.6992879","0.6978821","0.69644725","0.6943878","0.6927374","0.6871","0.6799098","0.67813987","0.672294","0.67222166","0.6721005","0.6701401","0.669934","0.669934","0.6693836","0.66794974","0.6649028","0.66480863","0.66474587","0.66440165","0.66361535","0.66150874","0.66088384","0.65973467","0.65959173","0.6591535","0.65867937","0.6564607","0.6524634","0.6515953","0.65032285","0.6496908","0.64796424","0.64648944","0.6460608","0.6459342","0.64584315","0.64575726","0.6449059","0.6439905","0.6439759","0.6432301","0.6431376","0.6430409","0.64197487","0.6404332","0.6392399","0.63820136","0.6344113","0.6335825","0.6327636","0.63269544","0.63252014","0.63209915","0.63138145","0.63114333","0.63100624","0.6294868","0.629389","0.6292062","0.6288971","0.62862957","0.6284247","0.62836844","0.62831414","0.6265681","0.6262584","0.62576854","0.62415385","0.62398183","0.6235391","0.6233871","0.62283456","0.6228024","0.6224066","0.62175494","0.6215568","0.6213969","0.62105113","0.6199439","0.6195405","0.6191261","0.6182253","0.6181165","0.61800414","0.6178457","0.6178361","0.6172835","0.6170689","0.6169638","0.61587214","0.61587","0.61497396","0.61487985","0.6142038"],"string":"[\n \"0.740472\",\n \"0.7184337\",\n \"0.71324676\",\n \"0.70474213\",\n \"0.703812\",\n \"0.70344573\",\n \"0.6992879\",\n \"0.6978821\",\n \"0.69644725\",\n \"0.6943878\",\n \"0.6927374\",\n \"0.6871\",\n \"0.6799098\",\n \"0.67813987\",\n \"0.672294\",\n \"0.67222166\",\n \"0.6721005\",\n \"0.6701401\",\n \"0.669934\",\n \"0.669934\",\n \"0.6693836\",\n \"0.66794974\",\n \"0.6649028\",\n \"0.66480863\",\n \"0.66474587\",\n \"0.66440165\",\n \"0.66361535\",\n \"0.66150874\",\n \"0.66088384\",\n \"0.65973467\",\n \"0.65959173\",\n \"0.6591535\",\n \"0.65867937\",\n \"0.6564607\",\n \"0.6524634\",\n \"0.6515953\",\n \"0.65032285\",\n \"0.6496908\",\n \"0.64796424\",\n \"0.64648944\",\n \"0.6460608\",\n \"0.6459342\",\n \"0.64584315\",\n \"0.64575726\",\n \"0.6449059\",\n \"0.6439905\",\n \"0.6439759\",\n \"0.6432301\",\n \"0.6431376\",\n \"0.6430409\",\n \"0.64197487\",\n \"0.6404332\",\n \"0.6392399\",\n \"0.63820136\",\n \"0.6344113\",\n \"0.6335825\",\n \"0.6327636\",\n \"0.63269544\",\n \"0.63252014\",\n \"0.63209915\",\n \"0.63138145\",\n \"0.63114333\",\n \"0.63100624\",\n \"0.6294868\",\n \"0.629389\",\n \"0.6292062\",\n \"0.6288971\",\n \"0.62862957\",\n \"0.6284247\",\n \"0.62836844\",\n \"0.62831414\",\n \"0.6265681\",\n \"0.6262584\",\n \"0.62576854\",\n \"0.62415385\",\n \"0.62398183\",\n \"0.6235391\",\n \"0.6233871\",\n \"0.62283456\",\n \"0.6228024\",\n \"0.6224066\",\n \"0.62175494\",\n \"0.6215568\",\n \"0.6213969\",\n \"0.62105113\",\n \"0.6199439\",\n \"0.6195405\",\n \"0.6191261\",\n \"0.6182253\",\n \"0.6181165\",\n \"0.61800414\",\n \"0.6178457\",\n \"0.6178361\",\n \"0.6172835\",\n \"0.6170689\",\n \"0.6169638\",\n \"0.61587214\",\n \"0.61587\",\n \"0.61497396\",\n \"0.61487985\",\n \"0.6142038\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12877,"cells":{"query":{"kind":"string","value":"Gets sys.argv and expecting a = format. Prints usage on error or request."},"document":{"kind":"string","value":"def parse_args(default=defaults,extra_usage='',required=['root']):\n \n vars = default\n \n if len(sys.argv)<2:\n usage(\"Error: You must at least pass the following arguments!\\n%s\\n%s\"%(str(required),extra_usage))\n \n #Some things someone may type to get help\n if sys.argv[1] in ['-h','--help','help','usage']:\n usage(extra_usage)\n \n for i in range(1,len(sys.argv)):\n s = sys.argv[i].split('=')\n if not len(s)==2:\n usage(\"\"\"Error: Incorrectly formatted Arguments, please use <Key>=<Value> !\\n\n Avoid any space characters and the equals sign.\\n%s\\n\"\"\"%extra_usage)\n vars[s[0]] = s[1]\n \n for req in required:\n if not req in vars:\n usage(\"Error: You must include the '%s' field!\\n%s\\n\"%(req,extra_usage))\n \n return vars"},"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 print_usage(arg_processor):\n min_width = max(map(lambda x : len(x),\\\n arg_processor.program_arg_order + arg_processor.program_flag_order))\n print \"Usage: python {} \".format(sys.argv[0])\n print \"The following flags and arguments can be supplied:\"\n print \"Flags:\"\n for flag in arg_processor.program_flag_order:\n print \" {:<{}} : {}\".format(flag, min_width,\n arg_processor.program_flags[flag].description)\n print \"Arguments:\"\n for arg in arg_processor.program_arg_order:\n if arg_processor.program_args[arg].validator != None:\n advice_str = arg_processor.advice_functions[\\\n arg_processor.program_args[arg].validator](\\\n arg_processor.program_args[arg].validator_args)\n else:\n advice_str = \"\"\n if arg_processor.program_args[arg].needed:\n print \" {:<{}} : {}{}\".format(arg, min_width,\n arg_processor.program_args[arg].description, advice_str)\n else:\n print \" {:<{}} : {}{} [optional, default: {}]\".format(arg,\n min_width, arg_processor.program_args[arg].description,\n advice_str, arg_processor.program_args[arg].default_value)\n sys.exit(0)","def check_argv():\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\"\\n\")[0], add_help=False)\n parser.add_argument(\"input_pairs_fn\", type=str)\n parser.add_argument(\"output_pairs_fn\", type=str)\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n return parser.parse_args()","def check_argv():\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\"\\n\")[0], add_help=False)\n parser.add_argument(\"segment_fn\", type=str, help=\"pickled segmentation file\")\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n return parser.parse_args()","def usage():\n\n print(\"\\nHere is how you can use this script\\n\")\n print(\"Usage: python %s\"%sys.argv[0])\n print(\"\\t --input=<file>\")","def check_argv():\n parser = argparse.ArgumentParser(\n description=__doc__.strip().split(\"\\n\")[0], add_help=False\n )\n parser.add_argument(\"npz_fn\", type=str, help=\"NumPy archive\")\n parser.add_argument(\n \"--metric\", choices=[\"cosine\", \"euclidean\", \"hamming\", \"chebyshev\"],\n default=\"cosine\",\n help=\"distance metric (default: %(default)s)\"\n )\n parser.add_argument(\n \"--mean_ap\", dest=\"mean_ap\", action=\"store_true\",\n help=\"also compute mean average precision (this is significantly \"\n \"more resource intensive)\"\n )\n parser.add_argument(\n \"--mvn\", action=\"store_true\",\n help=\"mean and variance normalise (default: False)\"\n )\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n return parser.parse_args()","def _usage():\n txt = f\"[INFO] Usage: {sys.argv[0]}\"\n txt += \" configfile topdatadir YYYYMM model_forcing\"\n print(txt)\n print(\"[INFO] where:\")\n print(\"[INFO] configfile is path to LDT parameter file\")\n print(\"[INFO] topdatadir is top-level directory for LIS data\")\n print(\"[INFO] YYYYMM is month to process\")\n print(\"[INFO] model_forcing is ID for atmospheric forcing for LIS\")","def _get_input_from_argv():\n payload_index = sys.argv.index('--') + 1\n params = sys.argv[payload_index:]\n if not params:\n raise ValueError(\n \"A JSON payload was expected after the -- delimiter, but none \"\n \"was found.\")\n return ' '.join(params)","def check_argv():\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\"\\n\")[0], add_help=False)\n parser.add_argument(\"keywordslist\", help=\"Numpy output file\")\n parser.add_argument(\"dirs\", help=\"Numpy output file\")\n parser.add_argument(\"npz_train\", help=\"Numpy output file\")\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n return parser.parse_args()","def do_usage():\r\n progname = sys.argv[0]\r\n if string.find(progname, os.sep) > -1:\r\n progname = string.split(sys.argv[0], os.sep)[-1]\r\n elif string.find(progname, os.altsep) > -1:\r\n progname = string.split(sys.argv[0], os.altsep)[-1]\r\n print \"\"\"\r\n%s (version: %s)\r\n\r\nUSAGE:\r\n\r\n \"-h\", \"-?\", \"help\", \"--help\", \"h\":\r\n prints this help message\r\n \r\n \"-v\", \"--verbose\":\r\n turns on verbose mode (prints useful messages about what the program is doing)\r\n\r\n \"-c\", \"--clean\":\r\n deletes all files from the temporary directory\r\n\r\n \"-ns\", \"--nostain\": \r\n don't use the stains (non-standard tinctures) of\r\n Murrey (dark reddish purple), Sanguine (blood red) and Tenné (orange) \r\n\r\n \"-s\", \"--silent\": \r\n don't produced any output messages at all \r\n\r\n n:(a number), n=(a number)\r\n sets the number of badges to create\r\n \r\n\"\"\" % (progname, __VERSION__)\r\n sys.exit()","def print_usage():\n print 'USAGE: %s [options]' % os.path.abspath(__file__)\n print 'EXAMPLE1: %s # FOR DEFAULTS' % os.path.abspath(__file__)\n print 'EXAMPLE2: %s 121f03=tweek hirap=towelie details=False # TWO SMALL SETS' % os.path.abspath(__file__)\n print 'EXAMPLE3: %s 121f03=tweek details=True # ONE DETAILED SET' % os.path.abspath(__file__)\n print 'EXAMPLE4: %s details=True # SHOWS MAX INFO' % os.path.abspath(__file__)","def PrintOurUsage():\n print 'Stub script %s (auto-generated). Options:' % sys.argv[0]\n print ('--helpstub '\n 'Show help for stub script.')\n print ('--debug_binary '\n 'Run python under debugger specified by --debugger.')\n print ('--debugger=<debugger> '\n \"Debugger for --debug_binary. Default: 'gdb --args'.\")\n print ('--debug_script '\n 'Run wrapped script with python debugger module (pdb).')\n print ('--show_command_and_exit '\n 'Print command which would be executed and exit.')\n print ('These options must appear first in the command line, all others will '\n 'be passed to the wrapped script.')","def usage():\n print(\"Usage: \" + sys.argv[0] + \" [-t title] [-l location] \\\n [-e email] [-p password]\\n\\r\\\n -e --email=EMAIL set your email for Google account\\n\\r\\\n -p --password=PASSWORD set password for your Google account\\n\\r\\\n -t --title=TITLE set title of event\\n\\r\\\n -l --location=LOCATION set location of event\\n\\r\\\n -c --calendar=CALENDAR set calendar name \\\n (default if not specifyed)\\n\\r\\\n -h --help display this help and exit\\n\\r\\\n -v --version display script version and exit\")","def print_usage():\r\n\tprint(\"Usage: python gddownloader.py arg\")\r\n\tprint(\"where arg can be one of the following:\")\r\n\tprint(\" github url (e.g. https://github.com/user/repo)\")\r\n\tprint(\" path to txt file containing github urls\")","def print_usage():\n print(\"usage: MILP.py -p <parameter file> -i <payoff file> -o <output file>\")\n print(\"-p, --params\\t sets the parameter file\")\n print(\"-i, --payoff\\t sets the payoff file\")\n print(\"-o, --output\\t sets the output file. Defaults to out.csv\")\n print(\"-d, --delimiter\\t sets the delimiter of ALL files. Defaults to csv\")","def usage(fd):\n fd.write('Usage:\\n')\n exe = os.path.basename(sys.argv[0])\n fd.write(\" %s <formula file> <sha> <os/arch> <root url>\\n\" % exe)\n fd.write('\\n')\n fd.write('For example:\\n')\n fd.write(\n \" %s /some/dir/gcc.rb 123... tiger_g3 https://some.server/bottles\\n\" \\\n % exe\n )","def check_argv():\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\"\\n\")[0])#, add_help=False)\n parser.add_argument(\n \"--model_dir\", type=str,\n help=\"if provided, this is the path where the model will be stored \"\n \"and where previous models would be searched for\",\n default=None\n )\n # parser.add_argument(\"--n_max_epochs\", type=int, default=None)\n return parser.parse_args()","def main_argv():\n main_parse_args(sys.argv[1:])","def main_argv():\n main_parse_args(sys.argv[1:])","def print_args():\r\n args = \", \".join(sys.argv)\r\n print(\"pfArgs: \" + args)","def usage():\n print('Usage: {} node0|node1 URL'.format(sys.argv[0]))\n sys.exit(1)","def usage():\n print(\"\"\"Usage:\n\\t%s storer - initialize storer machine\n\\t%s tester - initialize tester machine\n\\t%s --help - print this message\"\"\"% (sys.argv[0], sys.argv[0], sys.argv[0]))","def print_usage():\r\n print \"\"\r\n print \"\"\r\n print \" JoomFind v0.1\"\r\n print \"\"\r\n print \" Script made by Jasdev Singh\"\r\n print \"\"\r\n print \" This script is made only for educational and offline self-testing \"\r\n print \" purposes. The creator is not responsible or accountable for any \"\r\n print \" damage or loss caused that you perform with this script. \"\r\n print \"\"\r\n print \" Usage example:\"\r\n print '\\tpython joomfind.py -f filepath | -v'\r\n print \"\"\r\n print \" Put URL(s) to scan in a newline delimited file\"\r\n print \" URL(s) must point to homepage of the CMS \"\r\n print \"\"\r\n print \" Options:\"\r\n print \" -f filename (specify input file)\"\r\n print \" -v, --verbose (show detailed output)\"\r\n print \" --help (displays this help text)\"\r\n print \"\"\r\n return","def usage():\n print(\"usage: %s <N bound> <S bound> <W bound> <E bound> \" %\n (sys.argv[0]) +\n \"<fault file> <station file> <map prefix> <topo> <coastal> <border>\")","def command_line_arguments():\n\n try:\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\n\n # Add required arguments.\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\n\n # Parse the arguments\n args = parser.parse_args()\n\n return args\n\n except Exception as err:\n print(err)\n return","def print_usage():\n\n print \"Usage:\"\n print \" %s sign <priv_key> <cert> <file1 ...>\" % sys.argv[0]\n print \" %s verify <trust_dir> <file1 ...>\" % sys.argv[0]\n sys.exit(1)","def parse_cmdline(argv):\n if argv is None:\n argv = sys.argv[1:]\n\n # initialize the parser object:\n parser = argparse.ArgumentParser(description='Calculates A and Ea from Gaussian output files using GoodVibes. '\n 'List files to be analyzed, reactant(s) first and ending with the '\n 'transition structure. These can be listed on the command line or in '\n 'a file (each line listing a set of reactant(s) and transition '\n 'structure).')\n parser.add_argument(\"-d\", \"--out_dir\", help=\"A directory where output files should be saved. The default location \"\n \"is the current working directory.\", default=None)\n parser.add_argument(\"-f\", dest=\"freq_cutoff\", help=\"Cut-off frequency for both entropy and enthalpy (wavenumbers) \"\n \"(default = 0)\", default=\"0\")\n parser.add_argument(\"-l\", \"--list\", help=\"The location of the list of Gaussian output files. \"\n \"The default file name.\", default=None)\n parser.add_argument(\"-q\", \"--quasiharmonic\", help=\"Use the '-q' option in GoodVibes, which turns on turns on \"\n \"quasi-harmonic corrections to both entropy and enthalpy in the \"\n \"Gibbs free energy (qh-G(T)) output from GoodVibes. \",\n action='store_true')\n parser.add_argument(\"--temp\", help=\"Temperature in K for calculating \\u0394G. The default is the first \"\n \"temperature in 'temp_range' (if specified). If a value is given, the program \"\n \"will use the temperature closest to it in the temp_range.\", default=None)\n parser.add_argument(\"-ti\", \"--temp_range\", help=\"Initial temp, final temp, (and optionally) step size (K) for \"\n \"thermochemistry calculations. The default range is 300,600,30\",\n default=\"300,600,30\")\n parser.add_argument(\"-v\", \"--vib_scale\", help=\"Scaling factor to be used for vibrational frequencies. If not \"\n \"provided, the GoodVibes default value will be used.\",\n default=None)\n parser.add_argument(\"-p\", \"--plot\", help=\"Make a \\u0394G plot at the specified temp. The default is False.\",\n action='store_true')\n parser.add_argument(\"-pl\", \"--plot_labels\", help=\"Optional labels for \\u0394G plot. Enter as a list.\",\n default=None)\n parser.add_argument(\"-c\", \"--vibes_check\", help=\"In addition to standard checks always run (matching solvent, \"\n \"level of theory, stoichiometry, charge, multiplicity, and \"\n \"Gaussian versions), run files through GoodVibes '--check' before \"\n \"performing calculations. The default is False.\",\n action='store_true')\n parser.add_argument(\"-o\", \"--output_fname\", help=\"The name of the output file to be created. The default is the \"\n \"list name with the extension '.csv', or '{}' if no list name \"\n \"provided.\".format(DEF_OUT_FILE_NAME), default=None)\n\n parser.add_argument(\"-s\", \"--save_vibes\", help=\"Save the output from running GoodVibes in separate files, \"\n \"named with the Gaussian log file prefix and '.dat'. \"\n \"The default is False.\",\n action='store_true')\n parser.add_argument(\"-t\", \"--tog_vibes\", help=\"Save the output from running GoodVibes in one file, \"\n \"renamed with the output file prefix and '.dat'. \"\n \"The default is False.\",\n action='store_true')\n\n args = None\n try:\n args = parser.parse_known_args(argv)\n options = args[0]\n if not options.out_dir:\n options.out_dir = os.getcwd()\n # user can define a new directory as the output directory\n if not os.path.exists(options.out_dir):\n os.makedirs(options.out_dir)\n\n if options.output_fname:\n options.output_fname = os.path.abspath(os.path.join(options.out_dir, options.output_fname))\n elif options.list:\n options.output_fname = create_out_fname(options.list, ext='.csv', base_dir=options.out_dir)\n else:\n options.output_fname = create_out_fname(DEF_OUT_FILE_NAME, ext='.csv', base_dir=options.out_dir)\n\n if options.plot_labels:\n options.plot_labels = options.plot_labels.split(',')\n else:\n options.plot_labels = ['']\n\n if options.vib_scale:\n options.vib_scale = float(options.vib_scale)\n\n except (SystemExit, ValueError) as e:\n if hasattr(e, 'code') and e.code == 0:\n return args, GOOD_RET\n warning(e)\n parser.print_help()\n return args, INPUT_ERROR\n\n return args, GOOD_RET","def usage():\n\tprint \"Usage: \" + sys.argv[0] + \" --include\"","def get_args(argv):\r\n parser = argparse.ArgumentParser()\r\n parser.add_argument(\"design\", help=\"design file name\")\r\n parser.add_argument(\"-v\", \"--verbose\", action=\"store_true\",\r\n help=\"print a verbose report\")\r\n return parser.parse_args(argv)","def query_cmdline():","def show_usage():\n\n usage_screen = \"\\nUsage:\\n\" \\\n f\" {basename(argv[0])} <mock_1> [<mock_2> ...]\\n\" \\\n \"\\nOptions:\\n\" \\\n \" mock-departments Send HTTP requests to create some mock departments in the backend.\\n\" \\\n \" mock-employees Send HTTP requests to create some mock employees in the backend.\\n\" \\\n \" help Show this help page.\\n\" \\\n \"\" \\\n \" verbose Enables detailed request logging for the remaining options.\\n\"\n print(usage_screen)","def main(argv=None):\n\n if argv is None:\n argv = sys.argv","def usage():\n print(\"Usage:\")\n print(\"songtiment.py [-s \\\"song\\\"] -a \\\"artist\\\"\")","def main(argv=None):\n\n if argv is None:\n argv = sys.argv[1:]","def usage(progname):\n sys.stderr.write(\"usage: \" + progname + \" name n [mu sigma]\\n\")\n sys.stderr.write(\" name is attribute name\\n\");\n sys.stderr.write(\" n is the size of the sample\\n\");\n sys.stderr.write(\" mu is the mean(default 0)\\n\");\n sys.stderr.write(\" sigma is the standard deviation(default 1)\\n\");\n sys.exit(1)","def usage():\n txt = f\"[INFO] Usage: {(sys.argv[0])} FCST_SYR FCST_EYR MONTH_ABBR \"\\\n \t\"MONTH_NUM FCST_TYPE LEAD_MONTHS ENS_NUM CONFIG_FILE\"\n print(txt)\n print(\"[INFO] where\")\n print(\"[INFO] FCST_SYR: Start year of forecast\")\n print(\"[INFO] FCST_EYR: End year of forecast\")\n print(\"[INFO] MONTH_ABBR: Abbreviation of the initialization month\")\n print(\"[INFO] MONTH_NUM: Integer number of the initialization month\")\n print(\"[INFO] FCST_TYPE: Forecast type (should be nmme)\")\n print(\"[INFO] LEAD_MONTHS: Number of lead months\")\n print(\"[INFO] ENS_NUM: Integer number of ensembles\")\n print(\"[INFO] CONFIG_FILE: Configfile that sets up environment\")","def test_main_first_arg_help(capsys):\n with pytest.raises(SystemExit):\n uflash.main(argv=['--help'])\n\n stdout, _ = capsys.readouterr()\n # argparse manipulates the help text (e.g. changes line wrap)\n # so it isn't trivial to compare the output to uflash._HELP_TEXT.\n expected = 'Flash Python onto the BBC micro:bit'\n assert expected in stdout","def usage():","def usage():","def check_argv():\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\"\\n\")[0], add_help=False)\n parser.add_argument(\"data_dir\", type=str, help=\"data directory\")\n parser.add_argument(\n \"--init_am_n_iter\", type=int, help=\"default: %(default)s\",\n default=default_options_dict[\"init_am_n_iter\"]\n )\n parser.add_argument(\n \"--segment_n_iter\", type=int, help=\"default: %(default)s\",\n default=default_options_dict[\"segment_n_iter\"]\n )\n parser.add_argument(\n \"--K_max\", type=str, help=\"default: %(default)s\",\n default=default_options_dict[\"K_max\"]\n )\n parser.add_argument(\n \"--min_duration\", type=int, help=\"default: %(default)s\",\n default=default_options_dict[\"min_duration\"]\n )\n parser.add_argument(\n \"--n_slices_max\", type=int, help=\"default: %(default)s\",\n default=default_options_dict[\"n_slices_max\"]\n )\n parser.add_argument(\n \"--p_boundary_init\", type=float, help=\"default: %(default)s\",\n default=default_options_dict[\"p_boundary_init\"]\n ) \n parser.add_argument(\n \"--n_cpus\", type=int, help=\"default: %(default)s\",\n default=default_options_dict[\"n_cpus\"]\n )\n parser.add_argument(\n \"--n_batches\", type=int, help=\"default: %(default)s\",\n default=default_options_dict[\"n_batches\"]\n )\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n return parser.parse_args()","def treatCmdOpts(argv):\n baseName = os.path.basename(__file__)\n amc.cBaseName = colored(baseName, 'yellow')\n\n helpTxt = amc.cBaseName + ' analyses observation statistics file for selected GNSSs'\n\n # create the parser for command line arguments\n parser = argparse.ArgumentParser(description=helpTxt)\n\n parser.add_argument('--obsstat', help='observation statistics file', type=str, required=True)\n\n parser.add_argument('--freqs', help='select frequencies to use (out of {freqs:s}, default {freq:s})'.format(freqs='|'.join(gfzc.lst_freqs), freq=colored(gfzc.lst_freqs[0], 'green')), default=gfzc.lst_freqs[0], type=str, required=False, action=gco.freqtype_action, nargs='+')\n\n parser.add_argument('--cutoff', help='cutoff angle in degrees (default {mask:s})'.format(mask=colored('0', 'green')), default=0, type=int, required=False, action=gco.cutoff_action)\n\n parser.add_argument('--dbcvs', help='Add information to CVS database (default {cvsdb:s})'.format(cvsdb=colored(gco.CVSDB_OBSTLE, 'green')), required=False, type=str, default=gco.CVSDB_OBSTLE)\n\n parser.add_argument('--plot', help='displays interactive plots (default False)', action='store_true', required=False, default=False)\n\n parser.add_argument('--logging', help='specify logging level console/file (two of {choices:s}, default {choice:s})'.format(choices='|'.join(gco.lst_logging_choices), choice=colored(' '.join(gco.lst_logging_choices[3:5]), 'green')), nargs=2, required=False, default=gco.lst_logging_choices[3:5], action=gco.logging_action)\n\n # drop argv[0]\n args = parser.parse_args(argv[1:])\n\n # return arguments\n return args.obsstat, args.freqs, args.cutoff, args.dbcvs, args.plot, args.logging","def print_usage():\r\n print(\"USAGE: python[3] pso.py [<seed>] [<filename>]\")\r\n print(\" where:\")\r\n print(\"\\t[<seed>]\\tOPTIONAL - seed for the random generator\")\r\n print(\"\\t[<filename>]\\tOPTIONAL - name for the output file\")","def get_cli_arguments(self):\n pass","def printUsage():\n print\n print \"Usage: python FillRegression.py args\"\n print\n print \"where args are property pairs as follows....\"\n print \"IndependentBaseName=XXXX - path to the base filename of independent time series (no .csv or _01.csv at end)\"\n print \"DependentBaseName=XXXX - path to the base filename of dependent time series (no .csv or _01.csv at end)\"\n print \"IndepedentTSID=XXXX - the independent TSID to use in the IndependentTSID column of the statistics table\"\n print \"DepedentTSID=XXXX - the dependent TSID to use in the DependentTSID column of the statistics table\"\n print \"StatisticsFile=XXXX - path to the output statistics file\"\n print \"NumberOfEquations=XXXX - number of equations (1 or 12)\"\n return","def print_usage():\n print(helptxt)\n sys.exit(2)","def main(argv,required_arg,required_arg_type,optional_arg):\n \n # add optional_arguments to the parser\n for option in optional_arg:\n parse_option_dictionary[option]()\n \n # parse the command line\n passed_optional_arg, passed_required_arg = parser.parse_args(argv)\n \n required_arg_values = grabRequiredArgs(passed_required_arg,required_arg,\n required_arg_type)\n\n return required_arg_values, passed_optional_arg","def validate_args() -> bool:\n if len(argv) == 1 or \\\n '--help' in argv:\n print(usage)\n return False\n return True","def parse_cmdline(argv):\n\n parser = argparse.ArgumentParser(description='Print information about probable hung attempts')\n parser.add_argument('--des_services', action='store', help='')\n parser.add_argument('--section', action='store',\n help='Must be specified if not set in environment')\n parser.add_argument('--days', action='store', default=7, help='finished in last X days')\n parser.add_argument('--file', action='store')\n\n args = vars(parser.parse_args(argv)) # convert to dict\n\n return args","def read_arguments(argv):\n\tif argv[0] in ('1', '2'):\n\t\tconos_config['endpoint'] = endpoint[argv[0]]\n\telse:\n\t\tusage()\n\n\tif argv[1] in ('dev', 'test', 'int', 'prod'):\n\t\tconos_config['environment'] = argv[1]\n\t\tconos_config['sts_url'] = eval(argv[1] + '_sts_url')\n\t\tconos_config['aicuu_url'] = eval(argv[1] + '_aicuu_url')\n\telse:\n\t\tusage()\n\n\tif len(argv) == 6:\n\t\tconos_config['number_threads'] = '1'\n\telse:\n\t\tif argv[6] in ('1', '2', '3', '4', '5', '6', '7', '8'):\n\t\t\tconos_config['number_threads'] = argv[6]\n\t\telse:\n\t\t\tusage()\n\n\tconos_config['client_id'] = argv[2]\n\tconos_config['client_secret'] = argv[3]\n\tconos_config['input_file'] = argv[4]\n\tconos_config['output_file'] = argv[5]","def cli_arguments():\n\n parser = argparse.ArgumentParser(\n formatter_class=argparse.RawDescriptionHelpFormatter,\n usage=f\"\\n{Color.DETAIL}pdforce.py [-p <pdf>] [-w <wordlist>] [-e <encoding>] [-o <output>] [-c] [-h/--help]{Color.END}\",\n description=f\"{Color.EMPHASIS}{TITLE}\\nLightweight PDF password cracker. USE FOR LEGAL INTENTS ONLY.{Color.END}\",\n epilog=f\"{Color.EMPHASIS}Made by @poponealex - https://github.com/poponealex{Color.END}\",\n )\n\n parser.add_argument(\n \"-p\",\n \"--pdf\",\n type=str,\n help=f\"{Color.INFORMATION}Path to the pdf file.{Color.END}\",\n action=\"store\",\n default=\"\",\n )\n\n parser.add_argument(\n \"-w\",\n \"--wordlist\",\n type=str,\n help=f\"{Color.INFORMATION}Path to the wordlist.{Color.END}\",\n action=\"store\",\n default=\"\",\n )\n\n parser.add_argument(\n \"-e\",\n \"--encoding\",\n type=str,\n help=f\"{Color.INFORMATION}Specify an encoding for the wordlist (https://docs.python.org/3/library/codecs.html#standard-encodings). The default encoding is platform dependent. Use 'iso8859_1' for rockyou. {Color.END}\",\n action=\"store\",\n default=None,\n )\n\n parser.add_argument(\n \"-o\",\n \"--output\",\n help=f\"{Color.INFORMATION}Output the cracked password to a new file.{Color.END}\",\n action=\"store\",\n )\n\n parser.add_argument(\n \"-c\",\n \"--copy\",\n help=f\"{Color.INFORMATION}Copy the password to the clipboard.{Color.END}\",\n action=\"store_true\",\n )\n\n return parser.parse_args()","def parse_command_line(env):\n try:\n options = [\"help\",\n \"check\",\n \"version\",\n \"dir=\",\n ]\n input_options = sys.argv[1:]\n opts, _ = getopt.getopt( input_options, \"\", options )\n except getopt.GetoptError:\n help_msg( env )\n sys.exit( 1 )\n\n what_to_do = None\n for option, param in opts:\n if option == \"--help\":\n env[\"print_info\"] = False\n return help_msg\n if option == \"--version\":\n return version_msg\n if option == \"--check\":\n what_to_do = check_files\n if option == \"--dir\":\n env[\"input_dir\"] = os.path.join( param, env[\"input_dir_glob\"] )\n\n if what_to_do:\n return what_to_do\n if \"input_dir\" not in env:\n return help_msg\n # what to do but really?\n return check_files","def test_usage(self):\n # Make sure the usage message is shown when no arguments\n # are given and when the -h or --help option is given.\n for options in [], ['-h'], ['--help']:\n exit_code, output = run_cli(*options)\n assert \"Usage:\" in output","def printUsage(self):\n print >> sys.stderr\n print >> sys.stderr, \"usage \", self.programName+\":\"\n for pname, pvalue in self.neededParamsNames.items():\n print >> sys.stderr, \" \", pname, pvalue[3]\n for pname, pvalue in self.optionalParamsNames.items():\n print >> sys.stderr, \" [\",pname, pvalue[3], \"]\"","def _usage(args, contents): # pragma: no cover\n sys.exit(0)","def usage():\n print(\"\\n\" + \n \"The following are arguments required:\\n\" + \n \"-i: the density threshold.\\n\" +\n \"-o: the output file.\\n\" +\n \"-v: the bridge cut version (\" + \", \".join(BridgeCut.VERSIONS) + \").\\n\" + \n \"-t: the density threshold.\\n\" + \n \"\\n\" + \n \"Example Usage:\\n\" + \n \"python main.py -i \\\"../data/toy/toy-bowtie.txt\\\" -o \\\"../results/toy/toy-bowtie.txt\\\" -d 0 -v \\\"edge-c\\\" -t .5\" +\n \"\\n\")","def main():\n\tparser = setup_argument_parser()\n\targuments = parser.parse_args()\n\tto_print = arguments.to_print\n\techo(to_print)","def printCLIHelp():\n \n cmd = os.path.basename(sys.argv[0])\n print \"\"\"\n - quickCurve - \n\nPerform a liklihood analysis on Fermi LAT data. You can use the\ncommand line functions listed below or run this module from within\npython. For full documentation on this module execute 'pydoc\nquickCurve'.\n \n%s (-h|--help) ... This help text.\n \n%s (-i|--initialize) ... Generate a default config file called\n example.cfg. Edit this file and rename it <basename>.cfg for use\n in the quickLike module.\n\n%s (-a|--analyze) (-n |--basename=)<basename> ... Perform an analysis\n on <basename>. <basename> is the prefix used for this analysis.\n You must already have a configuration file if using the command\n line interface.\n\n\"\"\" %(cmd,cmd,cmd)","def usage(progname):\n sys.stderr.write(\"usage: \" + progname + \" data_dir num_samples num_seeds num_waves outputdir\\n\")\n sys.exit(1)","def parseCMDParam():\n\n progName = sys.argv[0]\n\n progName = extractFileName(progName)\n\n format = \"python \" + progName + \" [-h] -b binary_path -p hardware_platform -k private_key_path -x bootloader_hex_file_path\"\n\n example1 = \"\\t get help: \\n\" + \"\\t\\tpython \" + progName + \" -h\"\n\n example2 = \"\\t use inputImage.bin, MCHP-Curiosity-PIC32MZEF, private_key.pem , aws_bootloader.X.production.hex as parameter : \\n\" \\\n + \"\\t\\tpython \" + progName + \" -b inputImage.bin -p MCHP-Curiosity-PIC32MZEF -k private_key.pem -x aws_bootloader.X.production.hex\"\n\n usageMsg = format + \"\\n\\n\" + \"example usages:\" + \"\\n\" + example1 + \"\\n\" + example2\n\n parser = argparse.ArgumentParser(usage=usageMsg)\n\n parser.add_argument('-b', required=True, help=\" path of input binary image \")\n parser.add_argument('-p', required=True, help=\" hardware platform name \")\n parser.add_argument('-k', required=True, help=\" path of the private key used to sign the image \")\n parser.add_argument('-x', required=True, help=\" path of the bootloader hex file \")\n\n args = vars(parser.parse_args())\n\n inputImagePath = args[\"b\"]\n\n hardwarePlatform = args[\"p\"]\n\n privateKeyPath = args[\"k\"]\n\n bootloaderHexPath = args[\"x\"]\n\n return inputImagePath, hardwarePlatform, privateKeyPath, bootloaderHexPath","def checkArguments ( ) :\r\n\r\n if len( sys.argv ) <= 1 : return None\r\n\r\n\r\n # splits the arguments that contain quotes\r\n \r\n wordList = [ ]\r\n\r\n for argument in sys.argv :\r\n\r\n wordList.extend( argument.split( '\"' ) )\r\n\r\n\r\n # places all the arguments that start with \"--\" at the end, and joins the others into words\r\n\r\n noMinusList = [ ]\r\n\r\n minusList = [ ]\r\n\r\n argument = \"\"\r\n\r\n for word in wordList[ 1 : ] :\r\n\r\n # strips spaces and quotes\r\n \r\n word = word.strip( \" \\\"'\" ) \r\n\r\n if word.startswith( \"--\" ) :\r\n\r\n minusList.append( word )\r\n\r\n if len( argument ) > 0 : noMinusList.append( argument )\r\n\r\n argument = \"\"\r\n\r\n elif argument == \"\" :\r\n\r\n argument = word\r\n\r\n else :\r\n\r\n argument = argument + \" \" + word\r\n\r\n if len( argument ) > 0 : noMinusList.append( argument )\r\n\r\n\r\n # library = 1st argument of the form \"-- ... /\" that exists\r\n\r\n libraryPath = None\r\n\r\n for argument in minusList :\r\n\r\n if ( ( argument.endswith( os.sep ) ) and ( os.path.exists( argument.strip( \"- \" ) ) ) ) :\r\n\r\n libraryPath = argument.strip( \"-\" )\r\n\r\n break\r\n\r\n # recomposes the command line\r\n \r\n sys.argv = wordList[ : 1 ] + noMinusList + minusList \r\n\r\n return libraryPath","def usage():\n print \"\"\"\nUsages:\n ./lmf-merger.py -m file1 file2 outfile\n ./lmf-merger.py -s file1 ...\n example: ./lmf-merger.py data/lmf/ac_eko_dlouhe_50_xxx_lmf.xml \\\n data/lmf/ac_frs_dlouhe_50_xxx_lmf.xml ac_eko-frs_dlouhe_50_xxx_lmf.xml\n \"\"\"","def usage():\n print(\"This program runs with command line arguments.\\n\"\n \"Available parameters:\\n\"\n \"\\t-h --help : help\\n\"\n \"\\t-f : file name or path\\n\"\n \"\\t-k : key file\\n\"\n \"\\t-o : operaion\\n\"\n \"\\n\"\n \"There are 3 operations available:\\n\"\n \"\\t'1' --> add_sign() : adds hash to end of file\\n\"\n \"\\t'2' --> check() : checks if added hash and current hash are matched\\n\"\n \"\\t'3' --> remove_sign() : remove hash from end of file which has added with operion 1\\n\"\n \"\\n\"\n \"Example command: $python3 checker.py -f message.pdf -k key_file.txt -o 1\")","def convert_args(sys_argv, sys_word, sys_mat, sys_directions,\r\n wanted_directions):\r\n if len(sys_argv) != 5:\r\n print(PARAMETER_ERROR)\r\n elif os.path.isfile(sys_word) is False:\r\n print(WORD_ERROR + sys_word + MISSING_ERROR)\r\n elif os.path.isfile(sys_mat) is False:\r\n print(MATRIX_ERROR + sys_mat + MISSING_ERROR)\r\n elif directions_validity(sys_directions, wanted_directions) is False:\r\n print(DIRECTION_ERROR)\r\n else:\r\n return True","def main():\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\"--version\", help=\"print software version\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.version:\n print_version()\n sys.exit(0)\n else:\n parser.print_usage()\n print()\n print_err(\"error: no commands supplied\")\n sys.exit(-1)","def getopt():\n raise NotImplementedError()","def treatCmdOpts(argv):\n helpTxt = os.path.basename(__file__) + 'creates plots with time values until the jamming is detected'\n\n # create the parser for command line arguments\n parser = argparse.ArgumentParser(description=helpTxt)\n parser.add_argument('-f', '--file', help='Name of CSV file', required=True)\n parser.add_argument('-d', '--dir', help='Directory of CSV file, defaults to current', required=False, default='.')\n args = parser.parse_args()\n\n return args.file, args.dir","def help_args():\n pass","def get_args():\n parser = argparse.ArgumentParser(description='Download genome')\n parser.add_argument(\"accession\", help=\"NCBI Accession Number\")\n parser.add_argument(\"email\", help=\"E-mail address\")\n return parser.parse_args()","def check_cli():\n if \"--help\" in sys.argv or \"-h\" in sys.argv:\n _exit(__help__)\n debug = False\n if \"--debug\" in sys.argv:\n debug = True\n sys.argv.remove(\"--debug\")\n input_file_names = sys.argv[1:]\n return debug, input_file_names","def get_args():\n if len(sys.argv) == 3:\n return sys.argv[1:]\n print(\"USAGE: python3 extract_cds.py infile outfile\\n\\n\")\n exit()","def print_usage():\n usage_msg = \"\"\"\n%s.py -H <host or group> -P <path> -M <mode>\n\nUsage:\n -h, --help\n Print detailed help screen\n -H, --hostname=STRING\n Host name or group of hosts\n -V, --version\n Print version information\n -P, --path=STRING\n Path to rancid var directory. Usually the dir contains a logs dirs and hostgroup dirs\n Example : /usr/local/rancid/var\n -M, --mod=STRING\n Plugin mod. Must be one of the following : ping, hash, config, cards, filter, qos\n *ping:\n Check if all host in the hostgroup are up from the rancid point of view.\n It uses the .up file to determine the lists of host to look for\n *hash:\n Check if the firmware hash is different from the ref one (or from the previous one)\n *config:\n Check if the configuration has changed for the host / group (notify diff)\n *cards:\n Specific to 8600 models. Check the hardware cards plugged to the host (notify diff).\n *filter:\n Specific to ES-470. Check the filters (notify diff)\n *qos:\n Specific to ES-470. Check the qos values (notify diff)\n -u, --url=URL\n URL to submit passive results to Shinken Receiver with HTTP\n Need a host and service to send result.\n -a, --passive-host=STRING\n Required if not in plugin mod to send data to Shinken ws_arbiter\n -b, --passive-service=STRING\n Required if not in plugin mod to send data to Shinken ws_arbiter\n\"\"\" % PLUGIN_NAME\n print usage_msg","def handle_cmdline():\n\n cmdline = ArgumentParser(init_args=['address', 'arch', 'file'],\n address_required=True, address_default=None,\n file_required=True,\n file_help='Flash or memory image to inspect',\n formatter_class=RawDescriptionHelpFormatter,\n usage=_USAGE, description=_DESCRIPTION, epilog=_EPILOG)\n\n cmdline.add_argument('--longhelp',\n choices=['Y', 'N'],\n default=None,\n help=_LONGHELP_TEXT)\n\n cmdline.add_argument('--autocomplete',\n choices=['Y', 'N'],\n default=None,\n help=_AUTOCOMPLETE_TEXT)\n\n cmdline.add_argument('--threshold',\n type=int,\n default=5,\n help='Minimum table size to report. Default: 5')\n\n cmdline.add_argument('--subcmds',\n action='store_true',\n default=False,\n help='Include sub-command tables in displayed results')\n\n cmdline.add_argument('--details',\n action='store_true',\n default=False,\n help='Display more detailed output')\n\n args = cmdline.parse_args()\n\n if args.longhelp is not None:\n args.longhelp = args.longhelp == 'Y'\n\n if args.autocomplete is not None:\n args.autocomplete = args.autocomplete == 'Y'\n\n return args","def readArgs():\n args = sys.argv\n if len(args) != 3:\n print(\"ERROR - Wrong number of arguments! \\n\")\n print(\"Usage: plotGantt.py TYPE path/to/result/file.gantt \\n where TYPE is : MTS / SCH\")\n exit(5)\n if args[1] != \"MTS\" and args[1] != \"SCH\":\n print(\"ERROR - Wrong type specified! : \" + args[1])\n print(\"Usage: plotGantt.py TYPE path/to/result/file.gantt \\n where TYPE is : MTS / SCH\")\n return args","def print_usage(prog: str, prm: dict):\n\n\tprint()\n\tprint('Usage:')\n\tprint()\n\tprint(f'{prog} svc_name ' + ' '.join(['[%s=x]'%(x) for x in prm]))\n\tprint()\n\tprint('Default values for optional parameters:')\n\tprint()\n\tfor k,v in prm.items(): print(f'{k} : {v}')\n\tprint()\n\tsys.exit(-1)","def _usage():\n txt = \\\n f\"[INFO] Usage: {sys.argv[0]} lis_config_template restart_dir YYYYMMDD\"\n print(txt)\n print(\"[INFO] where: \")\n print(\"[INFO] lis_config_template: Path to sample lis.config file.\")\n print(\"[INFO] restart_dir: Path to LIS restart files.\")\n print(\"[INFO] YYYYMMDD: year/month/day of start of next LIS run.\")","def Usage():\r\n print \"Correct Usage:\"\r\n print \"python primesBelow.py <integer>\"","def get_cmd_line_args():\n parser = argparse.ArgumentParser(\n description=DOC, formatter_class=argparse.RawTextHelpFormatter)\n\n # Required arguments\n required = parser.add_argument_group(\"Required arguments\")\n required.add_argument(\n \"--fastq-regex\", required=True, type=is_fastq_regex, metavar=\"<regex>\",\n help=\n \"Snakemake regex used to infer the FASTQ files to process and the \"\n \"related wildcards: {sample} (mandatory), {lane} (optional) and \"\n \"{end} (mandatory if paired-end sequencing), e.g. \"\n \"/path/to/data/{sample}/{sample}_{ignore1}_{lane}_{end}_001.fastq.gz\"\n )\n required.add_argument(\n \"--outdir\", required=True, metavar=\"<dir>\", help=\"Output directory.\"\n )\n required.add_argument(\n \"--ref-build\", required=True, metavar=\"<version>\", help=\n \"Reference genome build, e.g. hg19 or mm10. Assuming the existence of \"\n \"the 3 following files in <--ref-genome-dir>: <ref build>.fa \"\n \"<ref build>.fa.fai and <ref build>.fa.dict\"\n )\n required.add_argument(\n \"--ref-genome-dir\", metavar=\"<dir>\", help=\n \"Bisulfite reference genome directory, including '<ref build>.fa', \"\n \"'<ref build>.fa.fai', '<ref build>.fa.dict' and the \"\n \"'Bisulfite_Genome' directory created by running the \"\n \"'bismark_genome_preparation' script. See README.md documentation.\"\n )\n\n\n # Optional general arguments\n optional = parser.add_argument_group(\"Optional\")\n optional.add_argument(\n \"--single-end\", action=\"store_false\", dest=\"paired_end\", help=\n \"By default paired-end sequencing is assumed, for single-end set this \"\n \"flag.\"\n )\n optional.add_argument(\n \"--rrbs\", action=\"store_true\", help=\n \"For Reduced Representation Bisulfite Sequencing (RRBS) set this flag.\"\n )\n optional.add_argument(\n \"--no-deduplication\", action=\"store_false\",\n dest=\"use_bismark_deduplicate\", help=\n \"Set this flag to not apply Bismark BAM deduplication. The deduplica\"\n \"tion removes reads with similar start/end positions on a given chromo\"\n \"some. It is not a valid PCR correction for RRBS or amplicon data. \"\n \"The deduplication is not applied if the --rrbs flag is set.\"\n )\n optional.add_argument(\n \"--non-directional-library\", action=\"store_false\",\n dest=\"directional_library\", help=\n \"By default the library is assumed to be directional, if not set this \"\n \"flag. See Bismark documentation for more information.\"\n )\n optional.add_argument(\n \"--target-bed\", type=is_file, metavar=\"<path>\", help=\n \"For targeted sequencing, the path to the BED file listing the regions\"\n \" targeted. Used only for read coverage computation. If no BED is pro\"\n \"vided the coverage will be computed on the whole reference genome.\"\n )\n optional.add_argument(\n \"--target-kit\", metavar=\"<name>\", help=\n \"For targeted sequencing, the name of the kit used to target to be \"\n \"reported in the preprocessing report. Does not affect processing.\"\n )\n optional.add_argument(\n \"--phred\", type=int, choices={33, 64}, default=DEFAULT_OF[\"phred\"],\n metavar=\"<33|64>\", help=\n \"Base quality encoding of input FASTQ files: 33|64, by default %i.\"\n % DEFAULT_OF[\"phred\"]\n )\n optional.add_argument(\n \"--r1-id\", default=DEFAULT_OF[\"r1_id\"], metavar=\"<ID>\", help=\n \"Case-insensitive ID used to identify R1 (forward) reads in paired-end\"\n \" sequencing, by default '%s'.\" % DEFAULT_OF[\"r1_id\"]\n )\n optional.add_argument(\n \"--r2-id\", default=DEFAULT_OF[\"r2_id\"], metavar=\"<ID>\", help=\n \"Case-insensitive ID used to identify R2 (reverse) reads in paired-end\"\n \" sequencing, by default '%s'.\" % DEFAULT_OF[\"r2_id\"]\n )\n optional.add_argument(\n \"--read-length\", type=int, metavar=\"<int>\", help=\n \"Length of reads (e.g. 150) to write in the HTML report. \"\n \"Does not affect the processing.\"\n )\n\n # Optional FastQC arguments\n fastqc = parser.add_argument_group(\"FastQC optional\")\n optional.add_argument(\n \"--fastqc-threads\", type=int, metavar=\"<int>\",\n default=DEFAULT_OF[\"fastqc\"][\"threads\"], help=\n \"FastQC '--threads' argument, by default %i.\"\n % DEFAULT_OF[\"fastqc\"][\"threads\"]\n )\n\n # Optional Trim Galore arguments\n trim_galore = parser.add_argument_group(\"Trim Galore optional\")\n ADAPTERS_URL = (\n \"https://support.illumina.com/bulletins/2016/12/what-sequences-do-i\"\n \"-use-for-adapter-trimming.html\")\n trim_galore.add_argument(\n \"--adapter-r1\", metavar=\"<sequence>\", help=\n \"Trim Galore '--adapter' argument: adapter sequence to be trimmed off \"\n \"read 1. Common sequences: %s\" % ADAPTERS_URL\n )\n trim_galore.add_argument(\n \"--adapter-r2\", metavar=\"<sequence>\", help=\n \"Trim Galore '--adapter2' argument: adapter sequence to be trimmed \"\n \"off read 2. Common sequences: %s\" % ADAPTERS_URL\n )\n trim_galore.add_argument(\n \"--quality\", type=int, default=DEFAULT_OF[\"trim_galore\"][\"quality\"],\n metavar=\"<int>\", help=\n \"Trim Galore '--quality' argument, by default %i.\"\n % DEFAULT_OF[\"trim_galore\"][\"quality\"]\n )\n trim_galore.add_argument(\n \"--stringency\", type=int, metavar=\"<int>\",\n default=DEFAULT_OF[\"trim_galore\"][\"stringency\"], help=\n \"Trim Galore '--stringency' argument: overlap with adapter sequence \"\n \"required to trim, by default %i (very stringent).\"\n % DEFAULT_OF[\"trim_galore\"][\"stringency\"]\n )\n trim_galore.add_argument(\n \"--min-length\", type=int, metavar=\"<int>\",\n default=DEFAULT_OF[\"trim_galore\"][\"min_length\"], help=\n \"Trim Galore '--length' argument: minimum read length after trimming \"\n \"otherwise removed, by default %i.\"\n % DEFAULT_OF[\"trim_galore\"][\"min_length\"]\n )\n trim_galore.add_argument(\n \"--error-rate\", type=float, metavar=\"<float>\",\n default=DEFAULT_OF[\"trim_galore\"][\"error_rate\"], help=\n \"Trim Galore '-e' argument: maximum allowed error rate with the \"\n \"matching region, by default {}\"\n .format(DEFAULT_OF[\"trim_galore\"][\"error_rate\"])\n )\n trim_galore.add_argument(\n \"--max-n\", type=int, metavar=\"<int>\", help=\n \"Trim Galore '--max_n' argument: Maximum number of 'N's in a read \"\n \"otherwise removed. By default not applied.\"\n )\n trim_galore.add_argument(\n \"--trim-n\", action=\"store_true\", help=\n \"Trim Galore '--trim-n' argument: remove 'N's from ends of the read.\"\n )\n trim_galore.add_argument(\n \"--clip-r1-5p\", type=int, metavar=\"<int>\", help=\n \"Trim Galore '--clip_R1' argument: remove basepairs from 5' end of \"\n \"read 1. Useful if there is a methylation bias at this end.\"\n )\n trim_galore.add_argument(\n \"--clip-r2-5p\", type=int, metavar=\"<int>\", help=\n \"Trim Galore '--clip_R2' argument: remove basepairs from 5' end of \"\n \"read 2. Useful if there is a methylation bias at this end.\"\n )\n trim_galore.add_argument(\n \"--clip-r1-3p\", type=int, metavar=\"<int>\", help=\n \"Trim Galore '--three_prime_clip_R1' argument: remove basepairs from \"\n \"3' end of read 1. Useful if there is a methylation bias at this end.\"\n )\n trim_galore.add_argument(\n \"--clip-r2-3p\", type=int, metavar=\"<int>\", help=\n \"Trim Galore '--three_prime_clip_R2' argument: remove basepairs from \"\n \"3' end of read 2. Useful if there is a methylation bias at this end.\"\n )\n\n # Optional Bismark tools arguments\n bismark = parser.add_argument_group(\"Bismark optional\")\n bismark.add_argument(\n \"--seed-mismatch\", type=int, choices=[0, 1], metavar=\"<0|1>\",\n default=DEFAULT_OF[\"bismark_bowtie2\"][\"seed_mismatch\"], help=\n \"Maximum number of mismatch allowed in a seed alignment: 0|1, \"\n \"by default %i.\" % DEFAULT_OF[\"bismark_bowtie2\"][\"seed_mismatch\"]\n )\n bismark.add_argument(\n \"--bowtie2-threads\", type=int, metavar=\"<int>\",\n default=DEFAULT_OF[\"bismark_bowtie2\"][\"threads\"], help=\n \"Bowtie2 '--threads' argument, by default %i\"\n % DEFAULT_OF[\"bismark_bowtie2\"][\"threads\"])\n bismark.add_argument(\n \"--meth-extract-threads\", type=int, metavar=\"<int>\",\n default=DEFAULT_OF[\"bismark_meth_extract\"][\"threads\"], help=\n \"bismark_methylation_extractor '--multicore' argument, by default %i.\"\n % DEFAULT_OF[\"bismark_meth_extract\"][\"threads\"]\n )\n\n # Optional Picard arguments\n picard = parser.add_argument_group(\"Picard optional\")\n picard.add_argument(\n \"--picard-jvm-args\", default=DEFAULT_OF[\"picard\"][\"jvm_args\"],\n metavar=\"<args>\", help=\n \"Java virtual machine arguments, e.g. to control starting and maximum \"\n \"heap size when running Picard, by default '%s'.\"\n % DEFAULT_OF[\"picard\"][\"jvm_args\"]\n )\n\n # Optional Samtools arguments\n samtools = parser.add_argument_group(\"Samtools optional\")\n samtools.add_argument(\n \"--samtools-threads\", type=int, metavar=\"<int>\",\n default=DEFAULT_OF[\"samtools\"][\"threads\"], help=\n \"Samtools '--threads' argument, by default %i\"\n % DEFAULT_OF[\"samtools\"][\"threads\"])\n\n # Parse the command line\n args = parser.parse_args()\n\n # For paired-end sequencing, check that the '{end}' wildcard is provided\n if args.paired_end is True and \"{end}\" not in args.fastq_regex:\n raise ValueError(\n \"The wildcard '{end}' is required in --fastq-regex argument when \"\n \"working with paired-end sequencing.\")\n\n # Set 'use_bismark_deduplicate' to False if RRBS data\n if args.rrbs is True:\n args.use_bismark_deduplicate = False\n\n # Check reference genome directory\n is_ref_genome_dir(args.ref_genome_dir, args.ref_build)\n\n # Convert the argparse object to a dict mapping <arg name> -> <val>\n kwargs = vars(args)\n\n return kwargs","def parse_cmdline():\n\tparser = ArgumentParser(prog=\"FastP_QC.py\", description=\"\"\"Script collects stats from fastp jsons.\"\"\")\n\tparser.add_argument(\"-r1\", \"--r1_stats\", dest=\"r1_stats\", action=\"store\", required=True, help=\"Text file with r1 stats, from q30.py script.\")\n\tparser.add_argument(\"-r2\", \"--r2_stats\", dest=\"r2_stats\", action=\"store\", required=True, help=\"Text file with r2 stats, from q30.py script.\")\n\tparser.add_argument(\"-n\", \"--name\", dest=\"name\", action=\"store\", required=True, help=\"Sample name\")\n\targs = parser.parse_args()\n\treturn args","def parse_command_line():\r\n\r\n parser = argparse.ArgumentParser(description='User args')\r\n parser.add_argument(\"--action\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\"Choose action.\")\r\n parser.add_argument(\"--model\", choices=['vgg', 'unet', 'fpn'], required=True, help=\"Choose model.\")\r\n parser.add_argument(\"--dataset\", choices=['full', 'small'], required=True, help=\"Choose dataset.\")\r\n\r\n return parser.parse_args()","def parse_parameters():\n parser = argparse.ArgumentParser(description='Program that checks for bad evaluations.')\n parser.usage = 'bettercorrectors [-h] client_id client_secret start_date [end_date] [--sql file]'\n parser.add_argument('client_id', help='the client_id of your intranet application', type=str)\n parser.add_argument('client_secret', help='the client_secret of your intra application', type=str)\n parser.add_argument('start_date', help='the latest date in iso format', type=datetime.fromisoformat)\n parser.add_argument('end_date', help='the closest date in iso format (optional)', type=datetime.fromisoformat,\n default=datetime.now(), nargs='?')\n parser.add_argument('--sql', dest='file', help='''name of the database file in case you want to save results in a \n sqlite database''', type=str)\n args = parser.parse_args()\n return args","def usage(progname):\n sys.stderr.write(\"usage: \" + progname + \n \" [-s id_list] [-i] [-t]\\n\"\n \" [-p preiviously_built_list]\\n\"\n \" [-g potential_upgrades_list]\\n\"\n \" [-u subsets_tap_stderr_file]\\n\"\n \" mods_file nochange_vht_file invidual_tap_stderr_file \"\n \"pairwise_tap_stderr_file budget\\n\")\n sys.stderr.write(\" -i : round all values to integer\\n\")\n sys.stderr.write(\" -s id_list : subsets of ids in id_list only\\n\")\n sys.stderr.write(\" -t timeperiod: add time period, intersrate to dzn\\n\")\n sys.stderr.write(\" -u substs_tap_stderr_file: data for triples also\\n\")\n sys.stderr.write(\" -p preiouvlys_built_list: list of previously built upgrades\\n\")\n sys.stderr.write(\" -g potential_upgrades_list: list of potenti upgrades to consider\\n\")\n sys.exit(1)","def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)","def parsingcommands(self):\n parser = argparse.ArgumentParser(\n description=\"httpfs is a simple file server.\")\n parser.add_argument(\"-v\", action=\"store_true\", dest=\"debug\",\n help=\"Prints debugging messages.\", default=False)\n parser.add_argument(\"-p\", action=\"store\", dest=\"port\",\n help=\"Specifies the port number that the server will listen and serve at. Default is 8080.\",\n type=int, default=8080)\n parser.add_argument(\"-d\", action=\"store\", dest=\"path_to_dir\",\n help=\"Specifies the directory that the server will use to read/writerequested files. \\\n Default is the current directory when launching theapplication.\",\n default='./')\n parser.add_argument(\"-arq\", action='store_true', dest=\"arq\", default=False, help=\"Automatic-Repeat-Request (ARQ)\")\n\n return parser.parse_args()","def _read_cmd_args():\n\n # Check if argument count is correct.\n if len(sys.argv) != 5:\n print(\"[ERR] Invalid number of command line arguments!\")\n _usage()\n sys.exit(1)\n\n # Get path to config file\n configfile = sys.argv[1]\n if not os.path.exists(configfile):\n print(f\"[ERR] Config file {configfile} does not exist!\")\n sys.exit(1)\n\n # Get top directory of LIS data\n topdatadir = sys.argv[2]\n if not os.path.exists(topdatadir):\n print(f\"[ERR] LIS data directory {topdatadir} does not exist!\")\n sys.exit(1)\n\n # Get valid year and month\n yyyymm = sys.argv[3]\n if len(yyyymm) != 6:\n print(\"[ERR] Invalid length of YYYYMM, must be 6 characters!\")\n sys.exit(1)\n year = int(yyyymm[0:4])\n month = int(yyyymm[4:6])\n try:\n startdate = datetime.datetime(year, month, day=1)\n except ValueError:\n print(\"[ERR] Invalid YYYYMM passed to script!\")\n sys.exit(1)\n\n # Get model forcing ID\n model_forcing = sys.argv[4]\n\n return configfile, topdatadir, startdate, model_forcing","def main():\r\n args = sys.argv\r\n print 'Script:', args[0]\r\n args.pop(0)\r\n for i, argument in enumerate(sys.argv):\r\n print 'Argument {}: {}'.format(i, argument)\r\n print 'Type: {}'.format(type(argument))","def read_cmd_args():\n\n if len(sys.argv) != 9:\n print(\"[ERR] Invalid number of command line arguments!\")\n usage()\n sys.exit(1)\n\n # FCST_SYR\n try:\n fcst_syr = int(sys.argv[1])\n except ValueError:\n print(f\"[ERR] Invalid argument for FCST_SYR! Received {(sys.argv[1])}\")\n usage()\n sys.exit(1)\n if fcst_syr < 0:\n print(f\"[ERR] Invalid argument for FCST_SYR! Received {(sys.argv[1])}\")\n usage()\n sys.exit(1)\n\n # FCST_EYR\n try:\n fcst_eyr = int(sys.argv[2])\n except ValueError:\n print(f\"[ERR] Invalid argument for FCST_EYR! Received {(sys.argv[2])}\")\n usage()\n sys.exit(1)\n if fcst_eyr < 0:\n print(f\"[ERR] Invalid argument for FCST_EYR! Received {(sys.argv[2])}\")\n usage()\n sys.exit(1)\n\n # MONTH_ABBR\n month_abbr = str(sys.argv[3])\n\n # MONTH_NUM\n try:\n month_num = int(sys.argv[4])\n except ValueError:\n print(f\"[ERR] Invalid argument for MONTH_NUM! Received {(sys.argv[4])}\")\n usage()\n sys.exit(1)\n if month_num < 1:\n print(f\"[ERR] Invalid argument for MONTH_NUM! Received {(sys.argv[4])}\")\n usage()\n sys.exit(1)\n if month_num > 12:\n print(f\"[ERR] Invalid argument for MONTH_NUM! Received {(sys.argv[4])}\")\n usage()\n sys.exit(1)\n\n # FCST_TYPE\n fcst_type = str(sys.argv[5])\n\n # LEAD_MONTHS\n try:\n lead_months = int(sys.argv[6])\n except ValueError:\n print(f\"[ERR] Invalid argument for LEAD_MONTHS! Received {(sys.argv[6])}\")\n usage()\n sys.exit(1)\n if lead_months < 0:\n print(f\"[ERR] Invalid argument for LEAD_MONTHS! Received {(sys.argv[6])}\")\n usage()\n sys.exit(1)\n\n # ENS_NUM\n try:\n ens_num = int(sys.argv[7])\n except ValueError:\n print(f\"[ERR] Invalid argument for ENS_NUM! Received {(sys.argv[7])}\")\n usage()\n sys.exit(1)\n if ens_num < 0:\n print(f\"[ERR] Invalid argument for ENS_NUM! Received {(sys.argv[7])}\")\n usage()\n sys.exit(1)\n\n # CONFIG_FILE\n config_file = sys.argv[8]\n if not os.path.exists(config_file):\n print(f\"[ERR] {config_file} does not exist!\")\n sys.exit(1)\n\n return fcst_syr, fcst_eyr, month_abbr, month_num, fcst_type, lead_months, \\\n \tens_num, config_file","def usage():\n print(\"Usage:\\n python NFLplayerSentiments.py 'QUERY' (remember to include the quotes).\")","def main():\n\n # If wrong number of arguments \n if len(sys.argv) == 1 or len(sys.argv) > 2:\n help()\n return\n \n # Otherwise pop out the command\n command = sys.argv.pop()\n\n # Test for which command\n if command == \"version\":\n version()\n elif command == \"help\":\n help()\n elif command == \"init\":\n init()\n elif command == \"make\":\n make()\n elif command == \"upload\":\n upload()","def usage():\n\n if len(sys.argv) != 3:\n print \"Usage: ./dnsclient.py <DNS name/IP> <query type>\"\n exit(0)","def setup_cmd_args():\n parser = argparse.ArgumentParser(description=\"This program will query G-POD and COPHUB on the same datasets, in order to obtain the number of data results, compare them compile a report with the differences.\", formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n # parser.add_argument(\"root_dir\", help=\"The root directory containing data to check\")\n # parser.add_argument(\"--workspace\", help=\"Set Workspace manually\")\n parser.add_argument(\"--outputlist\", help=\"Folder to write the output lists with the un-synced products.\", default=\"c:\\\\temp\\\\\")\n parser.add_argument(\"--daysback\", help=\"Report with a given number of days back from today\", default=0)\n parser.add_argument(\"--dataset\", help=\"Set which dataset to query (chose S3A_SR_1_SRA_A_PREOPS or S3B_SR_1_SRA_A_NTC)\")\n parser.add_argument(\"--startdate\", help=\" The Start Date (format: YYYY-MM-DD) \", default=\"2016-06-01\")\n parser.add_argument(\"--enddate\",help=\" The End Date (format: YYYY-MM-DD)\")\n parser.add_argument(\"--cphubuser\",help=\"COPHUB username\", required=True)\n parser.add_argument(\"--cphubpw\",help=\"COPHUB password\", required=True)\n parser.add_argument(\"-email\", type=str, help=\"Email to send the results\", action=\"append\")\n parser.add_argument('-t', action='store_true', help=\"Today as enddate. Otherwise the last day of the previous month is considered.\")\n parser.add_argument('-n', action='store_true', help=\"Normal numeric check\")\n parser.add_argument('-m', action='store_true', help=\"Monthly check with product listing.\")\n return parser.parse_args()","def parse_cmdline(argv):\n if argv is None:\n argv = sys.argv[1:]\n\n # initialize the parser object:\n parser = argparse.ArgumentParser(description='Changes a lammps data file by implementing options such as: '\n 'reorder atom ids in a lammps data file, given a dictionary to '\n 'reorder the atoms (a csv of old_index,new_index), and/or '\n 'change the atom, bond, angle, dihedral, and/or improper types,'\n 'given a dictionary to do so. Can also '\n 'print info for selected atom ids. ')\n parser.add_argument(\"-c\", \"--config\", help=\"The location of the configuration file in ini format.\"\n \"The default file name is {}, located in the \"\n \"base directory where the program as run.\".format(DEF_CFG_FILE),\n default=DEF_CFG_FILE, type=read_cfg)\n args = None\n try:\n args = parser.parse_args(argv)\n except IOError as e:\n warning(\"Problems reading file:\", e)\n parser.print_help()\n return args, IO_ERROR\n except (InvalidDataError, KeyError, MissingSectionHeaderError, SystemExit) as e:\n if hasattr(e, 'code') and e.code == 0:\n return args, GOOD_RET\n warning(e)\n parser.print_help()\n return args, INPUT_ERROR\n return args, GOOD_RET","def usage(arg):\r\n\r\n logging.debug('usage({})'.format(arg))\r\n\r\n myDocstring = \"\"\r\n if arg in [\"-i\", \"--info\"]:\r\n myDocstring = myDocstring+\"\\n\"+__doc__\r\n myDocstring = myDocstring+\"\\n AUTHOR\\n\\n $author$\\n\"\r\n myDocstring = myDocstring+\"\\n LICENSE\\n\\n $license$\\n\"\r\n parser.print_help()\r\n elif arg in [\"-v\", \"-i\", \"--version\", \"--info\"]:\r\n myDocstring = myDocstring+\"\\n VERSION\\n\\n $version$\\n\" \r\n myDocstring = myDocstring.replace('$version$', __version__)\r\n myDocstring = myDocstring.replace('$author$',__author__)\r\n myDocstring = myDocstring.replace('$license$',__license__)\r\n print(myDocstring)","def test_cli_help(run):\n msg = []\n _, err = run(dork.cli.the_predork_cli, msg, *(\"\", \"-h\"))\n assert \"usage: \" in msg[0], \\\n \"Failed to run the cli.main method: {err}\".format(err=err)","def usage():\n\tprint()\n\tprint(\n\t\t'\\t Usage: python conos_aicuu_client.py [-h] [--help] <ENDPOINT> <ENVIRONMENT> <CLIENT_ID> <CLIENT_SECRET> <INPUT_FILE> <OUTPUT_FILE> <NUMBER_THREAD>')\n\tprint('\\t -h : help')\n\tprint('\\t ENDPOINT : 1: /v1.0/person')\n\tprint('\\t 2: /v1.0/company')\n\tprint('\\t ENVIRONMENT : must be one of: dev, test, int, prod')\n\tprint('\\t CLIENT_ID : used for obtaining access token')\n\tprint('\\t CLIENT_SECRET : used for obtaining access token')\n\tprint('\\t INPUT_FILE : location of the request input file')\n\tprint('\\t OUTPUT_FILE : location of the output file (analyze report)')\n\tprint('\\t NUMBER_THREAD : (optional) number of threads to process data (from 1 -> 8, default is 1)')\n\tprint('\\n\\t Example : python conos_aicuu_client.py 1 test Admin 123456 data/person/input.txt data/person/output.txt 5')\n\texit(2)","def test_explicit_usage_message(self):\n assert 'Usage:' in main('coloredlogs', '--help', capture=True)","def make_parser():\n parser_ = argparse.ArgumentParser(\n description=\"\"\"\n A tool to retrieve history from\n (almost) any browser on (almost) any platform\n\n██████╗ ██████╗ ██████╗ ██╗ ██╗███████╗███████╗██████╗ ██╗ ██╗██╗███████╗████████╗ ██████╗ ██████╗ ██╗ ██╗\n██╔══██╗██╔══██╗██╔═══██╗██║ ██║██╔════╝██╔════╝██╔══██╗ ██║ ██║██║██╔════╝╚══██╔══╝██╔═══██╗██╔══██╗╚██╗ ██╔╝\n██████╔╝██████╔╝██║ ██║██║ █╗ ██║███████╗█████╗ ██████╔╝█████╗███████║██║███████╗ ██║ ██║ ██║██████╔╝ ╚████╔╝\n██╔══██╗██╔══██╗██║ ██║██║███╗██║╚════██║██╔══╝ ██╔══██╗╚════╝██╔══██║██║╚════██║ ██║ ██║ ██║██╔══██╗ ╚██╔╝\n██████╔╝██║ ██║╚██████╔╝╚███╔███╔╝███████║███████╗██║ ██║ ██║ ██║██║███████║ ██║ ╚██████╔╝██║ ██║ ██║\n╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚══╝╚══╝ ╚══════╝╚══════╝╚═╝ ╚═╝ ╚═╝ ╚═╝╚═╝╚══════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝\n \"\"\", # noqa: E501\n epilog=\"\"\"\n Checkout the GitHub repo\n https://github.com/pesos/browser-history\n if you have any issues or want to help contribute\"\"\",\n formatter_class=RawDescriptionHelpFormatter,\n )\n\n parser_.add_argument(\n \"-t\",\n \"--type\",\n default=\"history\",\n help=f\"\"\"\n argument to decide whether to retrieve history or bookmarks.\n Should be one of {AVAILABLE_TYPES}.\n Default is history.\"\"\",\n )\n parser_.add_argument(\n \"-b\",\n \"--browser\",\n default=\"all\",\n help=f\"\"\"\n browser to retrieve history or bookmarks from. Should be one\n of all, default, {AVAILABLE_BROWSERS}.\n Default is all (gets history or bookmarks from all browsers).\n \"\"\",\n )\n\n parser_.add_argument(\n \"-f\",\n \"--format\",\n default=\"infer\",\n help=f\"\"\"\n Format to be used in output. Should be one of {AVAILABLE_FORMATS}.\n Default is infer (format is inferred from the output file's\n extension. If no output file (-o) is specified, it defaults to csv)\"\"\",\n )\n\n parser_.add_argument(\n \"-o\",\n \"--output\",\n default=None,\n help=\"\"\"\n File where history output or bookmark output is to be written.\n If not provided, standard output is used.\"\"\",\n )\n\n parser_.add_argument(\n \"-p\",\n \"--profile\",\n default=None,\n help=\"\"\"\n Specify the profile from which to fetch history or bookmarks. If\n not provided all profiles are fetched\n \"\"\",\n )\n\n parser_.add_argument(\n \"--show-profiles\",\n default=None,\n metavar=\"BROWSER\",\n help=f\"\"\"\n List all available profiles for a given browser where browser\n can be one of default, {AVAILABLE_BROWSERS}. The browser\n must always be provided.\n \"\"\",\n )\n\n parser_.add_argument(\n \"-v\", \"--version\", action=\"version\", version=\"%(prog)s \" + __version__\n )\n\n return parser_","def cmd_help(args):","def display_usage():\n print >> sys.stderr, __doc__","def get_args():\n parser = argparse.ArgumentParser(\n description=\"Sets up package within the pheeno's directory.\"\n )\n\n # Required arguments\n parser.add_argument(\"-x\", \"--execute\", action=\"execute\", required=True,\n help=\"something\", default=False)\n\n # Optional arguments\n parser.add_argument(\"-s\", \"--save\", action=\"store\", required=False,\n help=\"something\", default=False)","def hotfix_deepobs_argparse():\n sys.argv = sys.argv[:1]","def parse_args(self, argv, env=None):\n env = env or os.environ\n self.argv = argv\n self.parser = HelpfulArgumentParser(add_help=False)\n self.parser.add_argument(\n '--help',\n action='store_true',\n help='prints usage information for the awx tool',\n )\n self.parser.add_argument(\n '--version',\n dest='conf.version',\n action='version',\n help='display awx CLI version',\n version=__version__\n )\n add_authentication_arguments(self.parser, env)\n add_output_formatting_arguments(self.parser, env)\n\n self.args = self.parser.parse_known_args(self.argv)[0]\n self.verbose = self.get_config('verbose')\n if self.verbose:\n logging.basicConfig(level='DEBUG')\n self.color = self.get_config('color')\n if not self.color:\n disable_color()\n fmt = self.get_config('format')\n if fmt not in FORMATTERS.keys():\n self.parser.error('No formatter %s available.' % (fmt))","def usage():\n print 'cpp file Generator.'\n print 'Usage:'\n print ' -h: help'\n print ' -i: file'\n print ' --help: help'\n print ' --in: help'\n sys.exit(1)"],"string":"[\n \"def print_usage(arg_processor):\\n min_width = max(map(lambda x : len(x),\\\\\\n arg_processor.program_arg_order + arg_processor.program_flag_order))\\n print \\\"Usage: python {} \\\".format(sys.argv[0])\\n print \\\"The following flags and arguments can be supplied:\\\"\\n print \\\"Flags:\\\"\\n for flag in arg_processor.program_flag_order:\\n print \\\" {:<{}} : {}\\\".format(flag, min_width,\\n arg_processor.program_flags[flag].description)\\n print \\\"Arguments:\\\"\\n for arg in arg_processor.program_arg_order:\\n if arg_processor.program_args[arg].validator != None:\\n advice_str = arg_processor.advice_functions[\\\\\\n arg_processor.program_args[arg].validator](\\\\\\n arg_processor.program_args[arg].validator_args)\\n else:\\n advice_str = \\\"\\\"\\n if arg_processor.program_args[arg].needed:\\n print \\\" {:<{}} : {}{}\\\".format(arg, min_width,\\n arg_processor.program_args[arg].description, advice_str)\\n else:\\n print \\\" {:<{}} : {}{} [optional, default: {}]\\\".format(arg,\\n min_width, arg_processor.program_args[arg].description,\\n advice_str, arg_processor.program_args[arg].default_value)\\n sys.exit(0)\",\n \"def check_argv():\\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\\\"\\\\n\\\")[0], add_help=False)\\n parser.add_argument(\\\"input_pairs_fn\\\", type=str)\\n parser.add_argument(\\\"output_pairs_fn\\\", type=str)\\n if len(sys.argv) == 1:\\n parser.print_help()\\n sys.exit(1)\\n return parser.parse_args()\",\n \"def check_argv():\\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\\\"\\\\n\\\")[0], add_help=False)\\n parser.add_argument(\\\"segment_fn\\\", type=str, help=\\\"pickled segmentation file\\\")\\n if len(sys.argv) == 1:\\n parser.print_help()\\n sys.exit(1)\\n return parser.parse_args()\",\n \"def usage():\\n\\n print(\\\"\\\\nHere is how you can use this script\\\\n\\\")\\n print(\\\"Usage: python %s\\\"%sys.argv[0])\\n print(\\\"\\\\t --input=<file>\\\")\",\n \"def check_argv():\\n parser = argparse.ArgumentParser(\\n description=__doc__.strip().split(\\\"\\\\n\\\")[0], add_help=False\\n )\\n parser.add_argument(\\\"npz_fn\\\", type=str, help=\\\"NumPy archive\\\")\\n parser.add_argument(\\n \\\"--metric\\\", choices=[\\\"cosine\\\", \\\"euclidean\\\", \\\"hamming\\\", \\\"chebyshev\\\"],\\n default=\\\"cosine\\\",\\n help=\\\"distance metric (default: %(default)s)\\\"\\n )\\n parser.add_argument(\\n \\\"--mean_ap\\\", dest=\\\"mean_ap\\\", action=\\\"store_true\\\",\\n help=\\\"also compute mean average precision (this is significantly \\\"\\n \\\"more resource intensive)\\\"\\n )\\n parser.add_argument(\\n \\\"--mvn\\\", action=\\\"store_true\\\",\\n help=\\\"mean and variance normalise (default: False)\\\"\\n )\\n if len(sys.argv) == 1:\\n parser.print_help()\\n sys.exit(1)\\n return parser.parse_args()\",\n \"def _usage():\\n txt = f\\\"[INFO] Usage: {sys.argv[0]}\\\"\\n txt += \\\" configfile topdatadir YYYYMM model_forcing\\\"\\n print(txt)\\n print(\\\"[INFO] where:\\\")\\n print(\\\"[INFO] configfile is path to LDT parameter file\\\")\\n print(\\\"[INFO] topdatadir is top-level directory for LIS data\\\")\\n print(\\\"[INFO] YYYYMM is month to process\\\")\\n print(\\\"[INFO] model_forcing is ID for atmospheric forcing for LIS\\\")\",\n \"def _get_input_from_argv():\\n payload_index = sys.argv.index('--') + 1\\n params = sys.argv[payload_index:]\\n if not params:\\n raise ValueError(\\n \\\"A JSON payload was expected after the -- delimiter, but none \\\"\\n \\\"was found.\\\")\\n return ' '.join(params)\",\n \"def check_argv():\\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\\\"\\\\n\\\")[0], add_help=False)\\n parser.add_argument(\\\"keywordslist\\\", help=\\\"Numpy output file\\\")\\n parser.add_argument(\\\"dirs\\\", help=\\\"Numpy output file\\\")\\n parser.add_argument(\\\"npz_train\\\", help=\\\"Numpy output file\\\")\\n if len(sys.argv) == 1:\\n parser.print_help()\\n sys.exit(1)\\n return parser.parse_args()\",\n \"def do_usage():\\r\\n progname = sys.argv[0]\\r\\n if string.find(progname, os.sep) > -1:\\r\\n progname = string.split(sys.argv[0], os.sep)[-1]\\r\\n elif string.find(progname, os.altsep) > -1:\\r\\n progname = string.split(sys.argv[0], os.altsep)[-1]\\r\\n print \\\"\\\"\\\"\\r\\n%s (version: %s)\\r\\n\\r\\nUSAGE:\\r\\n\\r\\n \\\"-h\\\", \\\"-?\\\", \\\"help\\\", \\\"--help\\\", \\\"h\\\":\\r\\n prints this help message\\r\\n \\r\\n \\\"-v\\\", \\\"--verbose\\\":\\r\\n turns on verbose mode (prints useful messages about what the program is doing)\\r\\n\\r\\n \\\"-c\\\", \\\"--clean\\\":\\r\\n deletes all files from the temporary directory\\r\\n\\r\\n \\\"-ns\\\", \\\"--nostain\\\": \\r\\n don't use the stains (non-standard tinctures) of\\r\\n Murrey (dark reddish purple), Sanguine (blood red) and Tenné (orange) \\r\\n\\r\\n \\\"-s\\\", \\\"--silent\\\": \\r\\n don't produced any output messages at all \\r\\n\\r\\n n:(a number), n=(a number)\\r\\n sets the number of badges to create\\r\\n \\r\\n\\\"\\\"\\\" % (progname, __VERSION__)\\r\\n sys.exit()\",\n \"def print_usage():\\n print 'USAGE: %s [options]' % os.path.abspath(__file__)\\n print 'EXAMPLE1: %s # FOR DEFAULTS' % os.path.abspath(__file__)\\n print 'EXAMPLE2: %s 121f03=tweek hirap=towelie details=False # TWO SMALL SETS' % os.path.abspath(__file__)\\n print 'EXAMPLE3: %s 121f03=tweek details=True # ONE DETAILED SET' % os.path.abspath(__file__)\\n print 'EXAMPLE4: %s details=True # SHOWS MAX INFO' % os.path.abspath(__file__)\",\n \"def PrintOurUsage():\\n print 'Stub script %s (auto-generated). Options:' % sys.argv[0]\\n print ('--helpstub '\\n 'Show help for stub script.')\\n print ('--debug_binary '\\n 'Run python under debugger specified by --debugger.')\\n print ('--debugger=<debugger> '\\n \\\"Debugger for --debug_binary. Default: 'gdb --args'.\\\")\\n print ('--debug_script '\\n 'Run wrapped script with python debugger module (pdb).')\\n print ('--show_command_and_exit '\\n 'Print command which would be executed and exit.')\\n print ('These options must appear first in the command line, all others will '\\n 'be passed to the wrapped script.')\",\n \"def usage():\\n print(\\\"Usage: \\\" + sys.argv[0] + \\\" [-t title] [-l location] \\\\\\n [-e email] [-p password]\\\\n\\\\r\\\\\\n -e --email=EMAIL set your email for Google account\\\\n\\\\r\\\\\\n -p --password=PASSWORD set password for your Google account\\\\n\\\\r\\\\\\n -t --title=TITLE set title of event\\\\n\\\\r\\\\\\n -l --location=LOCATION set location of event\\\\n\\\\r\\\\\\n -c --calendar=CALENDAR set calendar name \\\\\\n (default if not specifyed)\\\\n\\\\r\\\\\\n -h --help display this help and exit\\\\n\\\\r\\\\\\n -v --version display script version and exit\\\")\",\n \"def print_usage():\\r\\n\\tprint(\\\"Usage: python gddownloader.py arg\\\")\\r\\n\\tprint(\\\"where arg can be one of the following:\\\")\\r\\n\\tprint(\\\" github url (e.g. https://github.com/user/repo)\\\")\\r\\n\\tprint(\\\" path to txt file containing github urls\\\")\",\n \"def print_usage():\\n print(\\\"usage: MILP.py -p <parameter file> -i <payoff file> -o <output file>\\\")\\n print(\\\"-p, --params\\\\t sets the parameter file\\\")\\n print(\\\"-i, --payoff\\\\t sets the payoff file\\\")\\n print(\\\"-o, --output\\\\t sets the output file. Defaults to out.csv\\\")\\n print(\\\"-d, --delimiter\\\\t sets the delimiter of ALL files. Defaults to csv\\\")\",\n \"def usage(fd):\\n fd.write('Usage:\\\\n')\\n exe = os.path.basename(sys.argv[0])\\n fd.write(\\\" %s <formula file> <sha> <os/arch> <root url>\\\\n\\\" % exe)\\n fd.write('\\\\n')\\n fd.write('For example:\\\\n')\\n fd.write(\\n \\\" %s /some/dir/gcc.rb 123... tiger_g3 https://some.server/bottles\\\\n\\\" \\\\\\n % exe\\n )\",\n \"def check_argv():\\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\\\"\\\\n\\\")[0])#, add_help=False)\\n parser.add_argument(\\n \\\"--model_dir\\\", type=str,\\n help=\\\"if provided, this is the path where the model will be stored \\\"\\n \\\"and where previous models would be searched for\\\",\\n default=None\\n )\\n # parser.add_argument(\\\"--n_max_epochs\\\", type=int, default=None)\\n return parser.parse_args()\",\n \"def main_argv():\\n main_parse_args(sys.argv[1:])\",\n \"def main_argv():\\n main_parse_args(sys.argv[1:])\",\n \"def print_args():\\r\\n args = \\\", \\\".join(sys.argv)\\r\\n print(\\\"pfArgs: \\\" + args)\",\n \"def usage():\\n print('Usage: {} node0|node1 URL'.format(sys.argv[0]))\\n sys.exit(1)\",\n \"def usage():\\n print(\\\"\\\"\\\"Usage:\\n\\\\t%s storer - initialize storer machine\\n\\\\t%s tester - initialize tester machine\\n\\\\t%s --help - print this message\\\"\\\"\\\"% (sys.argv[0], sys.argv[0], sys.argv[0]))\",\n \"def print_usage():\\r\\n print \\\"\\\"\\r\\n print \\\"\\\"\\r\\n print \\\" JoomFind v0.1\\\"\\r\\n print \\\"\\\"\\r\\n print \\\" Script made by Jasdev Singh\\\"\\r\\n print \\\"\\\"\\r\\n print \\\" This script is made only for educational and offline self-testing \\\"\\r\\n print \\\" purposes. The creator is not responsible or accountable for any \\\"\\r\\n print \\\" damage or loss caused that you perform with this script. \\\"\\r\\n print \\\"\\\"\\r\\n print \\\" Usage example:\\\"\\r\\n print '\\\\tpython joomfind.py -f filepath | -v'\\r\\n print \\\"\\\"\\r\\n print \\\" Put URL(s) to scan in a newline delimited file\\\"\\r\\n print \\\" URL(s) must point to homepage of the CMS \\\"\\r\\n print \\\"\\\"\\r\\n print \\\" Options:\\\"\\r\\n print \\\" -f filename (specify input file)\\\"\\r\\n print \\\" -v, --verbose (show detailed output)\\\"\\r\\n print \\\" --help (displays this help text)\\\"\\r\\n print \\\"\\\"\\r\\n return\",\n \"def usage():\\n print(\\\"usage: %s <N bound> <S bound> <W bound> <E bound> \\\" %\\n (sys.argv[0]) +\\n \\\"<fault file> <station file> <map prefix> <topo> <coastal> <border>\\\")\",\n \"def command_line_arguments():\\n\\n try:\\n parser = argparse.ArgumentParser(description='Log Handler/Cleaner/Copier for Idemia DocAuth')\\n\\n # Add required arguments.\\n parser.add_argument('action', choices=['clean', 'download'], type=str, help='clean or download')\\n\\n # Parse the arguments\\n args = parser.parse_args()\\n\\n return args\\n\\n except Exception as err:\\n print(err)\\n return\",\n \"def print_usage():\\n\\n print \\\"Usage:\\\"\\n print \\\" %s sign <priv_key> <cert> <file1 ...>\\\" % sys.argv[0]\\n print \\\" %s verify <trust_dir> <file1 ...>\\\" % sys.argv[0]\\n sys.exit(1)\",\n \"def parse_cmdline(argv):\\n if argv is None:\\n argv = sys.argv[1:]\\n\\n # initialize the parser object:\\n parser = argparse.ArgumentParser(description='Calculates A and Ea from Gaussian output files using GoodVibes. '\\n 'List files to be analyzed, reactant(s) first and ending with the '\\n 'transition structure. These can be listed on the command line or in '\\n 'a file (each line listing a set of reactant(s) and transition '\\n 'structure).')\\n parser.add_argument(\\\"-d\\\", \\\"--out_dir\\\", help=\\\"A directory where output files should be saved. The default location \\\"\\n \\\"is the current working directory.\\\", default=None)\\n parser.add_argument(\\\"-f\\\", dest=\\\"freq_cutoff\\\", help=\\\"Cut-off frequency for both entropy and enthalpy (wavenumbers) \\\"\\n \\\"(default = 0)\\\", default=\\\"0\\\")\\n parser.add_argument(\\\"-l\\\", \\\"--list\\\", help=\\\"The location of the list of Gaussian output files. \\\"\\n \\\"The default file name.\\\", default=None)\\n parser.add_argument(\\\"-q\\\", \\\"--quasiharmonic\\\", help=\\\"Use the '-q' option in GoodVibes, which turns on turns on \\\"\\n \\\"quasi-harmonic corrections to both entropy and enthalpy in the \\\"\\n \\\"Gibbs free energy (qh-G(T)) output from GoodVibes. \\\",\\n action='store_true')\\n parser.add_argument(\\\"--temp\\\", help=\\\"Temperature in K for calculating \\\\u0394G. The default is the first \\\"\\n \\\"temperature in 'temp_range' (if specified). If a value is given, the program \\\"\\n \\\"will use the temperature closest to it in the temp_range.\\\", default=None)\\n parser.add_argument(\\\"-ti\\\", \\\"--temp_range\\\", help=\\\"Initial temp, final temp, (and optionally) step size (K) for \\\"\\n \\\"thermochemistry calculations. The default range is 300,600,30\\\",\\n default=\\\"300,600,30\\\")\\n parser.add_argument(\\\"-v\\\", \\\"--vib_scale\\\", help=\\\"Scaling factor to be used for vibrational frequencies. If not \\\"\\n \\\"provided, the GoodVibes default value will be used.\\\",\\n default=None)\\n parser.add_argument(\\\"-p\\\", \\\"--plot\\\", help=\\\"Make a \\\\u0394G plot at the specified temp. The default is False.\\\",\\n action='store_true')\\n parser.add_argument(\\\"-pl\\\", \\\"--plot_labels\\\", help=\\\"Optional labels for \\\\u0394G plot. Enter as a list.\\\",\\n default=None)\\n parser.add_argument(\\\"-c\\\", \\\"--vibes_check\\\", help=\\\"In addition to standard checks always run (matching solvent, \\\"\\n \\\"level of theory, stoichiometry, charge, multiplicity, and \\\"\\n \\\"Gaussian versions), run files through GoodVibes '--check' before \\\"\\n \\\"performing calculations. The default is False.\\\",\\n action='store_true')\\n parser.add_argument(\\\"-o\\\", \\\"--output_fname\\\", help=\\\"The name of the output file to be created. The default is the \\\"\\n \\\"list name with the extension '.csv', or '{}' if no list name \\\"\\n \\\"provided.\\\".format(DEF_OUT_FILE_NAME), default=None)\\n\\n parser.add_argument(\\\"-s\\\", \\\"--save_vibes\\\", help=\\\"Save the output from running GoodVibes in separate files, \\\"\\n \\\"named with the Gaussian log file prefix and '.dat'. \\\"\\n \\\"The default is False.\\\",\\n action='store_true')\\n parser.add_argument(\\\"-t\\\", \\\"--tog_vibes\\\", help=\\\"Save the output from running GoodVibes in one file, \\\"\\n \\\"renamed with the output file prefix and '.dat'. \\\"\\n \\\"The default is False.\\\",\\n action='store_true')\\n\\n args = None\\n try:\\n args = parser.parse_known_args(argv)\\n options = args[0]\\n if not options.out_dir:\\n options.out_dir = os.getcwd()\\n # user can define a new directory as the output directory\\n if not os.path.exists(options.out_dir):\\n os.makedirs(options.out_dir)\\n\\n if options.output_fname:\\n options.output_fname = os.path.abspath(os.path.join(options.out_dir, options.output_fname))\\n elif options.list:\\n options.output_fname = create_out_fname(options.list, ext='.csv', base_dir=options.out_dir)\\n else:\\n options.output_fname = create_out_fname(DEF_OUT_FILE_NAME, ext='.csv', base_dir=options.out_dir)\\n\\n if options.plot_labels:\\n options.plot_labels = options.plot_labels.split(',')\\n else:\\n options.plot_labels = ['']\\n\\n if options.vib_scale:\\n options.vib_scale = float(options.vib_scale)\\n\\n except (SystemExit, ValueError) as e:\\n if hasattr(e, 'code') and e.code == 0:\\n return args, GOOD_RET\\n warning(e)\\n parser.print_help()\\n return args, INPUT_ERROR\\n\\n return args, GOOD_RET\",\n \"def usage():\\n\\tprint \\\"Usage: \\\" + sys.argv[0] + \\\" --include\\\"\",\n \"def get_args(argv):\\r\\n parser = argparse.ArgumentParser()\\r\\n parser.add_argument(\\\"design\\\", help=\\\"design file name\\\")\\r\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", action=\\\"store_true\\\",\\r\\n help=\\\"print a verbose report\\\")\\r\\n return parser.parse_args(argv)\",\n \"def query_cmdline():\",\n \"def show_usage():\\n\\n usage_screen = \\\"\\\\nUsage:\\\\n\\\" \\\\\\n f\\\" {basename(argv[0])} <mock_1> [<mock_2> ...]\\\\n\\\" \\\\\\n \\\"\\\\nOptions:\\\\n\\\" \\\\\\n \\\" mock-departments Send HTTP requests to create some mock departments in the backend.\\\\n\\\" \\\\\\n \\\" mock-employees Send HTTP requests to create some mock employees in the backend.\\\\n\\\" \\\\\\n \\\" help Show this help page.\\\\n\\\" \\\\\\n \\\"\\\" \\\\\\n \\\" verbose Enables detailed request logging for the remaining options.\\\\n\\\"\\n print(usage_screen)\",\n \"def main(argv=None):\\n\\n if argv is None:\\n argv = sys.argv\",\n \"def usage():\\n print(\\\"Usage:\\\")\\n print(\\\"songtiment.py [-s \\\\\\\"song\\\\\\\"] -a \\\\\\\"artist\\\\\\\"\\\")\",\n \"def main(argv=None):\\n\\n if argv is None:\\n argv = sys.argv[1:]\",\n \"def usage(progname):\\n sys.stderr.write(\\\"usage: \\\" + progname + \\\" name n [mu sigma]\\\\n\\\")\\n sys.stderr.write(\\\" name is attribute name\\\\n\\\");\\n sys.stderr.write(\\\" n is the size of the sample\\\\n\\\");\\n sys.stderr.write(\\\" mu is the mean(default 0)\\\\n\\\");\\n sys.stderr.write(\\\" sigma is the standard deviation(default 1)\\\\n\\\");\\n sys.exit(1)\",\n \"def usage():\\n txt = f\\\"[INFO] Usage: {(sys.argv[0])} FCST_SYR FCST_EYR MONTH_ABBR \\\"\\\\\\n \\t\\\"MONTH_NUM FCST_TYPE LEAD_MONTHS ENS_NUM CONFIG_FILE\\\"\\n print(txt)\\n print(\\\"[INFO] where\\\")\\n print(\\\"[INFO] FCST_SYR: Start year of forecast\\\")\\n print(\\\"[INFO] FCST_EYR: End year of forecast\\\")\\n print(\\\"[INFO] MONTH_ABBR: Abbreviation of the initialization month\\\")\\n print(\\\"[INFO] MONTH_NUM: Integer number of the initialization month\\\")\\n print(\\\"[INFO] FCST_TYPE: Forecast type (should be nmme)\\\")\\n print(\\\"[INFO] LEAD_MONTHS: Number of lead months\\\")\\n print(\\\"[INFO] ENS_NUM: Integer number of ensembles\\\")\\n print(\\\"[INFO] CONFIG_FILE: Configfile that sets up environment\\\")\",\n \"def test_main_first_arg_help(capsys):\\n with pytest.raises(SystemExit):\\n uflash.main(argv=['--help'])\\n\\n stdout, _ = capsys.readouterr()\\n # argparse manipulates the help text (e.g. changes line wrap)\\n # so it isn't trivial to compare the output to uflash._HELP_TEXT.\\n expected = 'Flash Python onto the BBC micro:bit'\\n assert expected in stdout\",\n \"def usage():\",\n \"def usage():\",\n \"def check_argv():\\n parser = argparse.ArgumentParser(description=__doc__.strip().split(\\\"\\\\n\\\")[0], add_help=False)\\n parser.add_argument(\\\"data_dir\\\", type=str, help=\\\"data directory\\\")\\n parser.add_argument(\\n \\\"--init_am_n_iter\\\", type=int, help=\\\"default: %(default)s\\\",\\n default=default_options_dict[\\\"init_am_n_iter\\\"]\\n )\\n parser.add_argument(\\n \\\"--segment_n_iter\\\", type=int, help=\\\"default: %(default)s\\\",\\n default=default_options_dict[\\\"segment_n_iter\\\"]\\n )\\n parser.add_argument(\\n \\\"--K_max\\\", type=str, help=\\\"default: %(default)s\\\",\\n default=default_options_dict[\\\"K_max\\\"]\\n )\\n parser.add_argument(\\n \\\"--min_duration\\\", type=int, help=\\\"default: %(default)s\\\",\\n default=default_options_dict[\\\"min_duration\\\"]\\n )\\n parser.add_argument(\\n \\\"--n_slices_max\\\", type=int, help=\\\"default: %(default)s\\\",\\n default=default_options_dict[\\\"n_slices_max\\\"]\\n )\\n parser.add_argument(\\n \\\"--p_boundary_init\\\", type=float, help=\\\"default: %(default)s\\\",\\n default=default_options_dict[\\\"p_boundary_init\\\"]\\n ) \\n parser.add_argument(\\n \\\"--n_cpus\\\", type=int, help=\\\"default: %(default)s\\\",\\n default=default_options_dict[\\\"n_cpus\\\"]\\n )\\n parser.add_argument(\\n \\\"--n_batches\\\", type=int, help=\\\"default: %(default)s\\\",\\n default=default_options_dict[\\\"n_batches\\\"]\\n )\\n if len(sys.argv) == 1:\\n parser.print_help()\\n sys.exit(1)\\n return parser.parse_args()\",\n \"def treatCmdOpts(argv):\\n baseName = os.path.basename(__file__)\\n amc.cBaseName = colored(baseName, 'yellow')\\n\\n helpTxt = amc.cBaseName + ' analyses observation statistics file for selected GNSSs'\\n\\n # create the parser for command line arguments\\n parser = argparse.ArgumentParser(description=helpTxt)\\n\\n parser.add_argument('--obsstat', help='observation statistics file', type=str, required=True)\\n\\n parser.add_argument('--freqs', help='select frequencies to use (out of {freqs:s}, default {freq:s})'.format(freqs='|'.join(gfzc.lst_freqs), freq=colored(gfzc.lst_freqs[0], 'green')), default=gfzc.lst_freqs[0], type=str, required=False, action=gco.freqtype_action, nargs='+')\\n\\n parser.add_argument('--cutoff', help='cutoff angle in degrees (default {mask:s})'.format(mask=colored('0', 'green')), default=0, type=int, required=False, action=gco.cutoff_action)\\n\\n parser.add_argument('--dbcvs', help='Add information to CVS database (default {cvsdb:s})'.format(cvsdb=colored(gco.CVSDB_OBSTLE, 'green')), required=False, type=str, default=gco.CVSDB_OBSTLE)\\n\\n parser.add_argument('--plot', help='displays interactive plots (default False)', action='store_true', required=False, default=False)\\n\\n parser.add_argument('--logging', help='specify logging level console/file (two of {choices:s}, default {choice:s})'.format(choices='|'.join(gco.lst_logging_choices), choice=colored(' '.join(gco.lst_logging_choices[3:5]), 'green')), nargs=2, required=False, default=gco.lst_logging_choices[3:5], action=gco.logging_action)\\n\\n # drop argv[0]\\n args = parser.parse_args(argv[1:])\\n\\n # return arguments\\n return args.obsstat, args.freqs, args.cutoff, args.dbcvs, args.plot, args.logging\",\n \"def print_usage():\\r\\n print(\\\"USAGE: python[3] pso.py [<seed>] [<filename>]\\\")\\r\\n print(\\\" where:\\\")\\r\\n print(\\\"\\\\t[<seed>]\\\\tOPTIONAL - seed for the random generator\\\")\\r\\n print(\\\"\\\\t[<filename>]\\\\tOPTIONAL - name for the output file\\\")\",\n \"def get_cli_arguments(self):\\n pass\",\n \"def printUsage():\\n print\\n print \\\"Usage: python FillRegression.py args\\\"\\n print\\n print \\\"where args are property pairs as follows....\\\"\\n print \\\"IndependentBaseName=XXXX - path to the base filename of independent time series (no .csv or _01.csv at end)\\\"\\n print \\\"DependentBaseName=XXXX - path to the base filename of dependent time series (no .csv or _01.csv at end)\\\"\\n print \\\"IndepedentTSID=XXXX - the independent TSID to use in the IndependentTSID column of the statistics table\\\"\\n print \\\"DepedentTSID=XXXX - the dependent TSID to use in the DependentTSID column of the statistics table\\\"\\n print \\\"StatisticsFile=XXXX - path to the output statistics file\\\"\\n print \\\"NumberOfEquations=XXXX - number of equations (1 or 12)\\\"\\n return\",\n \"def print_usage():\\n print(helptxt)\\n sys.exit(2)\",\n \"def main(argv,required_arg,required_arg_type,optional_arg):\\n \\n # add optional_arguments to the parser\\n for option in optional_arg:\\n parse_option_dictionary[option]()\\n \\n # parse the command line\\n passed_optional_arg, passed_required_arg = parser.parse_args(argv)\\n \\n required_arg_values = grabRequiredArgs(passed_required_arg,required_arg,\\n required_arg_type)\\n\\n return required_arg_values, passed_optional_arg\",\n \"def validate_args() -> bool:\\n if len(argv) == 1 or \\\\\\n '--help' in argv:\\n print(usage)\\n return False\\n return True\",\n \"def parse_cmdline(argv):\\n\\n parser = argparse.ArgumentParser(description='Print information about probable hung attempts')\\n parser.add_argument('--des_services', action='store', help='')\\n parser.add_argument('--section', action='store',\\n help='Must be specified if not set in environment')\\n parser.add_argument('--days', action='store', default=7, help='finished in last X days')\\n parser.add_argument('--file', action='store')\\n\\n args = vars(parser.parse_args(argv)) # convert to dict\\n\\n return args\",\n \"def read_arguments(argv):\\n\\tif argv[0] in ('1', '2'):\\n\\t\\tconos_config['endpoint'] = endpoint[argv[0]]\\n\\telse:\\n\\t\\tusage()\\n\\n\\tif argv[1] in ('dev', 'test', 'int', 'prod'):\\n\\t\\tconos_config['environment'] = argv[1]\\n\\t\\tconos_config['sts_url'] = eval(argv[1] + '_sts_url')\\n\\t\\tconos_config['aicuu_url'] = eval(argv[1] + '_aicuu_url')\\n\\telse:\\n\\t\\tusage()\\n\\n\\tif len(argv) == 6:\\n\\t\\tconos_config['number_threads'] = '1'\\n\\telse:\\n\\t\\tif argv[6] in ('1', '2', '3', '4', '5', '6', '7', '8'):\\n\\t\\t\\tconos_config['number_threads'] = argv[6]\\n\\t\\telse:\\n\\t\\t\\tusage()\\n\\n\\tconos_config['client_id'] = argv[2]\\n\\tconos_config['client_secret'] = argv[3]\\n\\tconos_config['input_file'] = argv[4]\\n\\tconos_config['output_file'] = argv[5]\",\n \"def cli_arguments():\\n\\n parser = argparse.ArgumentParser(\\n formatter_class=argparse.RawDescriptionHelpFormatter,\\n usage=f\\\"\\\\n{Color.DETAIL}pdforce.py [-p <pdf>] [-w <wordlist>] [-e <encoding>] [-o <output>] [-c] [-h/--help]{Color.END}\\\",\\n description=f\\\"{Color.EMPHASIS}{TITLE}\\\\nLightweight PDF password cracker. USE FOR LEGAL INTENTS ONLY.{Color.END}\\\",\\n epilog=f\\\"{Color.EMPHASIS}Made by @poponealex - https://github.com/poponealex{Color.END}\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-p\\\",\\n \\\"--pdf\\\",\\n type=str,\\n help=f\\\"{Color.INFORMATION}Path to the pdf file.{Color.END}\\\",\\n action=\\\"store\\\",\\n default=\\\"\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-w\\\",\\n \\\"--wordlist\\\",\\n type=str,\\n help=f\\\"{Color.INFORMATION}Path to the wordlist.{Color.END}\\\",\\n action=\\\"store\\\",\\n default=\\\"\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-e\\\",\\n \\\"--encoding\\\",\\n type=str,\\n help=f\\\"{Color.INFORMATION}Specify an encoding for the wordlist (https://docs.python.org/3/library/codecs.html#standard-encodings). The default encoding is platform dependent. Use 'iso8859_1' for rockyou. {Color.END}\\\",\\n action=\\\"store\\\",\\n default=None,\\n )\\n\\n parser.add_argument(\\n \\\"-o\\\",\\n \\\"--output\\\",\\n help=f\\\"{Color.INFORMATION}Output the cracked password to a new file.{Color.END}\\\",\\n action=\\\"store\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-c\\\",\\n \\\"--copy\\\",\\n help=f\\\"{Color.INFORMATION}Copy the password to the clipboard.{Color.END}\\\",\\n action=\\\"store_true\\\",\\n )\\n\\n return parser.parse_args()\",\n \"def parse_command_line(env):\\n try:\\n options = [\\\"help\\\",\\n \\\"check\\\",\\n \\\"version\\\",\\n \\\"dir=\\\",\\n ]\\n input_options = sys.argv[1:]\\n opts, _ = getopt.getopt( input_options, \\\"\\\", options )\\n except getopt.GetoptError:\\n help_msg( env )\\n sys.exit( 1 )\\n\\n what_to_do = None\\n for option, param in opts:\\n if option == \\\"--help\\\":\\n env[\\\"print_info\\\"] = False\\n return help_msg\\n if option == \\\"--version\\\":\\n return version_msg\\n if option == \\\"--check\\\":\\n what_to_do = check_files\\n if option == \\\"--dir\\\":\\n env[\\\"input_dir\\\"] = os.path.join( param, env[\\\"input_dir_glob\\\"] )\\n\\n if what_to_do:\\n return what_to_do\\n if \\\"input_dir\\\" not in env:\\n return help_msg\\n # what to do but really?\\n return check_files\",\n \"def test_usage(self):\\n # Make sure the usage message is shown when no arguments\\n # are given and when the -h or --help option is given.\\n for options in [], ['-h'], ['--help']:\\n exit_code, output = run_cli(*options)\\n assert \\\"Usage:\\\" in output\",\n \"def printUsage(self):\\n print >> sys.stderr\\n print >> sys.stderr, \\\"usage \\\", self.programName+\\\":\\\"\\n for pname, pvalue in self.neededParamsNames.items():\\n print >> sys.stderr, \\\" \\\", pname, pvalue[3]\\n for pname, pvalue in self.optionalParamsNames.items():\\n print >> sys.stderr, \\\" [\\\",pname, pvalue[3], \\\"]\\\"\",\n \"def _usage(args, contents): # pragma: no cover\\n sys.exit(0)\",\n \"def usage():\\n print(\\\"\\\\n\\\" + \\n \\\"The following are arguments required:\\\\n\\\" + \\n \\\"-i: the density threshold.\\\\n\\\" +\\n \\\"-o: the output file.\\\\n\\\" +\\n \\\"-v: the bridge cut version (\\\" + \\\", \\\".join(BridgeCut.VERSIONS) + \\\").\\\\n\\\" + \\n \\\"-t: the density threshold.\\\\n\\\" + \\n \\\"\\\\n\\\" + \\n \\\"Example Usage:\\\\n\\\" + \\n \\\"python main.py -i \\\\\\\"../data/toy/toy-bowtie.txt\\\\\\\" -o \\\\\\\"../results/toy/toy-bowtie.txt\\\\\\\" -d 0 -v \\\\\\\"edge-c\\\\\\\" -t .5\\\" +\\n \\\"\\\\n\\\")\",\n \"def main():\\n\\tparser = setup_argument_parser()\\n\\targuments = parser.parse_args()\\n\\tto_print = arguments.to_print\\n\\techo(to_print)\",\n \"def printCLIHelp():\\n \\n cmd = os.path.basename(sys.argv[0])\\n print \\\"\\\"\\\"\\n - quickCurve - \\n\\nPerform a liklihood analysis on Fermi LAT data. You can use the\\ncommand line functions listed below or run this module from within\\npython. For full documentation on this module execute 'pydoc\\nquickCurve'.\\n \\n%s (-h|--help) ... This help text.\\n \\n%s (-i|--initialize) ... Generate a default config file called\\n example.cfg. Edit this file and rename it <basename>.cfg for use\\n in the quickLike module.\\n\\n%s (-a|--analyze) (-n |--basename=)<basename> ... Perform an analysis\\n on <basename>. <basename> is the prefix used for this analysis.\\n You must already have a configuration file if using the command\\n line interface.\\n\\n\\\"\\\"\\\" %(cmd,cmd,cmd)\",\n \"def usage(progname):\\n sys.stderr.write(\\\"usage: \\\" + progname + \\\" data_dir num_samples num_seeds num_waves outputdir\\\\n\\\")\\n sys.exit(1)\",\n \"def parseCMDParam():\\n\\n progName = sys.argv[0]\\n\\n progName = extractFileName(progName)\\n\\n format = \\\"python \\\" + progName + \\\" [-h] -b binary_path -p hardware_platform -k private_key_path -x bootloader_hex_file_path\\\"\\n\\n example1 = \\\"\\\\t get help: \\\\n\\\" + \\\"\\\\t\\\\tpython \\\" + progName + \\\" -h\\\"\\n\\n example2 = \\\"\\\\t use inputImage.bin, MCHP-Curiosity-PIC32MZEF, private_key.pem , aws_bootloader.X.production.hex as parameter : \\\\n\\\" \\\\\\n + \\\"\\\\t\\\\tpython \\\" + progName + \\\" -b inputImage.bin -p MCHP-Curiosity-PIC32MZEF -k private_key.pem -x aws_bootloader.X.production.hex\\\"\\n\\n usageMsg = format + \\\"\\\\n\\\\n\\\" + \\\"example usages:\\\" + \\\"\\\\n\\\" + example1 + \\\"\\\\n\\\" + example2\\n\\n parser = argparse.ArgumentParser(usage=usageMsg)\\n\\n parser.add_argument('-b', required=True, help=\\\" path of input binary image \\\")\\n parser.add_argument('-p', required=True, help=\\\" hardware platform name \\\")\\n parser.add_argument('-k', required=True, help=\\\" path of the private key used to sign the image \\\")\\n parser.add_argument('-x', required=True, help=\\\" path of the bootloader hex file \\\")\\n\\n args = vars(parser.parse_args())\\n\\n inputImagePath = args[\\\"b\\\"]\\n\\n hardwarePlatform = args[\\\"p\\\"]\\n\\n privateKeyPath = args[\\\"k\\\"]\\n\\n bootloaderHexPath = args[\\\"x\\\"]\\n\\n return inputImagePath, hardwarePlatform, privateKeyPath, bootloaderHexPath\",\n \"def checkArguments ( ) :\\r\\n\\r\\n if len( sys.argv ) <= 1 : return None\\r\\n\\r\\n\\r\\n # splits the arguments that contain quotes\\r\\n \\r\\n wordList = [ ]\\r\\n\\r\\n for argument in sys.argv :\\r\\n\\r\\n wordList.extend( argument.split( '\\\"' ) )\\r\\n\\r\\n\\r\\n # places all the arguments that start with \\\"--\\\" at the end, and joins the others into words\\r\\n\\r\\n noMinusList = [ ]\\r\\n\\r\\n minusList = [ ]\\r\\n\\r\\n argument = \\\"\\\"\\r\\n\\r\\n for word in wordList[ 1 : ] :\\r\\n\\r\\n # strips spaces and quotes\\r\\n \\r\\n word = word.strip( \\\" \\\\\\\"'\\\" ) \\r\\n\\r\\n if word.startswith( \\\"--\\\" ) :\\r\\n\\r\\n minusList.append( word )\\r\\n\\r\\n if len( argument ) > 0 : noMinusList.append( argument )\\r\\n\\r\\n argument = \\\"\\\"\\r\\n\\r\\n elif argument == \\\"\\\" :\\r\\n\\r\\n argument = word\\r\\n\\r\\n else :\\r\\n\\r\\n argument = argument + \\\" \\\" + word\\r\\n\\r\\n if len( argument ) > 0 : noMinusList.append( argument )\\r\\n\\r\\n\\r\\n # library = 1st argument of the form \\\"-- ... /\\\" that exists\\r\\n\\r\\n libraryPath = None\\r\\n\\r\\n for argument in minusList :\\r\\n\\r\\n if ( ( argument.endswith( os.sep ) ) and ( os.path.exists( argument.strip( \\\"- \\\" ) ) ) ) :\\r\\n\\r\\n libraryPath = argument.strip( \\\"-\\\" )\\r\\n\\r\\n break\\r\\n\\r\\n # recomposes the command line\\r\\n \\r\\n sys.argv = wordList[ : 1 ] + noMinusList + minusList \\r\\n\\r\\n return libraryPath\",\n \"def usage():\\n print \\\"\\\"\\\"\\nUsages:\\n ./lmf-merger.py -m file1 file2 outfile\\n ./lmf-merger.py -s file1 ...\\n example: ./lmf-merger.py data/lmf/ac_eko_dlouhe_50_xxx_lmf.xml \\\\\\n data/lmf/ac_frs_dlouhe_50_xxx_lmf.xml ac_eko-frs_dlouhe_50_xxx_lmf.xml\\n \\\"\\\"\\\"\",\n \"def usage():\\n print(\\\"This program runs with command line arguments.\\\\n\\\"\\n \\\"Available parameters:\\\\n\\\"\\n \\\"\\\\t-h --help : help\\\\n\\\"\\n \\\"\\\\t-f : file name or path\\\\n\\\"\\n \\\"\\\\t-k : key file\\\\n\\\"\\n \\\"\\\\t-o : operaion\\\\n\\\"\\n \\\"\\\\n\\\"\\n \\\"There are 3 operations available:\\\\n\\\"\\n \\\"\\\\t'1' --> add_sign() : adds hash to end of file\\\\n\\\"\\n \\\"\\\\t'2' --> check() : checks if added hash and current hash are matched\\\\n\\\"\\n \\\"\\\\t'3' --> remove_sign() : remove hash from end of file which has added with operion 1\\\\n\\\"\\n \\\"\\\\n\\\"\\n \\\"Example command: $python3 checker.py -f message.pdf -k key_file.txt -o 1\\\")\",\n \"def convert_args(sys_argv, sys_word, sys_mat, sys_directions,\\r\\n wanted_directions):\\r\\n if len(sys_argv) != 5:\\r\\n print(PARAMETER_ERROR)\\r\\n elif os.path.isfile(sys_word) is False:\\r\\n print(WORD_ERROR + sys_word + MISSING_ERROR)\\r\\n elif os.path.isfile(sys_mat) is False:\\r\\n print(MATRIX_ERROR + sys_mat + MISSING_ERROR)\\r\\n elif directions_validity(sys_directions, wanted_directions) is False:\\r\\n print(DIRECTION_ERROR)\\r\\n else:\\r\\n return True\",\n \"def main():\\n parser = argparse.ArgumentParser(description=__doc__)\\n parser.add_argument(\\\"--version\\\", help=\\\"print software version\\\", action=\\\"store_true\\\")\\n args = parser.parse_args()\\n\\n if args.version:\\n print_version()\\n sys.exit(0)\\n else:\\n parser.print_usage()\\n print()\\n print_err(\\\"error: no commands supplied\\\")\\n sys.exit(-1)\",\n \"def getopt():\\n raise NotImplementedError()\",\n \"def treatCmdOpts(argv):\\n helpTxt = os.path.basename(__file__) + 'creates plots with time values until the jamming is detected'\\n\\n # create the parser for command line arguments\\n parser = argparse.ArgumentParser(description=helpTxt)\\n parser.add_argument('-f', '--file', help='Name of CSV file', required=True)\\n parser.add_argument('-d', '--dir', help='Directory of CSV file, defaults to current', required=False, default='.')\\n args = parser.parse_args()\\n\\n return args.file, args.dir\",\n \"def help_args():\\n pass\",\n \"def get_args():\\n parser = argparse.ArgumentParser(description='Download genome')\\n parser.add_argument(\\\"accession\\\", help=\\\"NCBI Accession Number\\\")\\n parser.add_argument(\\\"email\\\", help=\\\"E-mail address\\\")\\n return parser.parse_args()\",\n \"def check_cli():\\n if \\\"--help\\\" in sys.argv or \\\"-h\\\" in sys.argv:\\n _exit(__help__)\\n debug = False\\n if \\\"--debug\\\" in sys.argv:\\n debug = True\\n sys.argv.remove(\\\"--debug\\\")\\n input_file_names = sys.argv[1:]\\n return debug, input_file_names\",\n \"def get_args():\\n if len(sys.argv) == 3:\\n return sys.argv[1:]\\n print(\\\"USAGE: python3 extract_cds.py infile outfile\\\\n\\\\n\\\")\\n exit()\",\n \"def print_usage():\\n usage_msg = \\\"\\\"\\\"\\n%s.py -H <host or group> -P <path> -M <mode>\\n\\nUsage:\\n -h, --help\\n Print detailed help screen\\n -H, --hostname=STRING\\n Host name or group of hosts\\n -V, --version\\n Print version information\\n -P, --path=STRING\\n Path to rancid var directory. Usually the dir contains a logs dirs and hostgroup dirs\\n Example : /usr/local/rancid/var\\n -M, --mod=STRING\\n Plugin mod. Must be one of the following : ping, hash, config, cards, filter, qos\\n *ping:\\n Check if all host in the hostgroup are up from the rancid point of view.\\n It uses the .up file to determine the lists of host to look for\\n *hash:\\n Check if the firmware hash is different from the ref one (or from the previous one)\\n *config:\\n Check if the configuration has changed for the host / group (notify diff)\\n *cards:\\n Specific to 8600 models. Check the hardware cards plugged to the host (notify diff).\\n *filter:\\n Specific to ES-470. Check the filters (notify diff)\\n *qos:\\n Specific to ES-470. Check the qos values (notify diff)\\n -u, --url=URL\\n URL to submit passive results to Shinken Receiver with HTTP\\n Need a host and service to send result.\\n -a, --passive-host=STRING\\n Required if not in plugin mod to send data to Shinken ws_arbiter\\n -b, --passive-service=STRING\\n Required if not in plugin mod to send data to Shinken ws_arbiter\\n\\\"\\\"\\\" % PLUGIN_NAME\\n print usage_msg\",\n \"def handle_cmdline():\\n\\n cmdline = ArgumentParser(init_args=['address', 'arch', 'file'],\\n address_required=True, address_default=None,\\n file_required=True,\\n file_help='Flash or memory image to inspect',\\n formatter_class=RawDescriptionHelpFormatter,\\n usage=_USAGE, description=_DESCRIPTION, epilog=_EPILOG)\\n\\n cmdline.add_argument('--longhelp',\\n choices=['Y', 'N'],\\n default=None,\\n help=_LONGHELP_TEXT)\\n\\n cmdline.add_argument('--autocomplete',\\n choices=['Y', 'N'],\\n default=None,\\n help=_AUTOCOMPLETE_TEXT)\\n\\n cmdline.add_argument('--threshold',\\n type=int,\\n default=5,\\n help='Minimum table size to report. Default: 5')\\n\\n cmdline.add_argument('--subcmds',\\n action='store_true',\\n default=False,\\n help='Include sub-command tables in displayed results')\\n\\n cmdline.add_argument('--details',\\n action='store_true',\\n default=False,\\n help='Display more detailed output')\\n\\n args = cmdline.parse_args()\\n\\n if args.longhelp is not None:\\n args.longhelp = args.longhelp == 'Y'\\n\\n if args.autocomplete is not None:\\n args.autocomplete = args.autocomplete == 'Y'\\n\\n return args\",\n \"def readArgs():\\n args = sys.argv\\n if len(args) != 3:\\n print(\\\"ERROR - Wrong number of arguments! \\\\n\\\")\\n print(\\\"Usage: plotGantt.py TYPE path/to/result/file.gantt \\\\n where TYPE is : MTS / SCH\\\")\\n exit(5)\\n if args[1] != \\\"MTS\\\" and args[1] != \\\"SCH\\\":\\n print(\\\"ERROR - Wrong type specified! : \\\" + args[1])\\n print(\\\"Usage: plotGantt.py TYPE path/to/result/file.gantt \\\\n where TYPE is : MTS / SCH\\\")\\n return args\",\n \"def print_usage(prog: str, prm: dict):\\n\\n\\tprint()\\n\\tprint('Usage:')\\n\\tprint()\\n\\tprint(f'{prog} svc_name ' + ' '.join(['[%s=x]'%(x) for x in prm]))\\n\\tprint()\\n\\tprint('Default values for optional parameters:')\\n\\tprint()\\n\\tfor k,v in prm.items(): print(f'{k} : {v}')\\n\\tprint()\\n\\tsys.exit(-1)\",\n \"def _usage():\\n txt = \\\\\\n f\\\"[INFO] Usage: {sys.argv[0]} lis_config_template restart_dir YYYYMMDD\\\"\\n print(txt)\\n print(\\\"[INFO] where: \\\")\\n print(\\\"[INFO] lis_config_template: Path to sample lis.config file.\\\")\\n print(\\\"[INFO] restart_dir: Path to LIS restart files.\\\")\\n print(\\\"[INFO] YYYYMMDD: year/month/day of start of next LIS run.\\\")\",\n \"def Usage():\\r\\n print \\\"Correct Usage:\\\"\\r\\n print \\\"python primesBelow.py <integer>\\\"\",\n \"def get_cmd_line_args():\\n parser = argparse.ArgumentParser(\\n description=DOC, formatter_class=argparse.RawTextHelpFormatter)\\n\\n # Required arguments\\n required = parser.add_argument_group(\\\"Required arguments\\\")\\n required.add_argument(\\n \\\"--fastq-regex\\\", required=True, type=is_fastq_regex, metavar=\\\"<regex>\\\",\\n help=\\n \\\"Snakemake regex used to infer the FASTQ files to process and the \\\"\\n \\\"related wildcards: {sample} (mandatory), {lane} (optional) and \\\"\\n \\\"{end} (mandatory if paired-end sequencing), e.g. \\\"\\n \\\"/path/to/data/{sample}/{sample}_{ignore1}_{lane}_{end}_001.fastq.gz\\\"\\n )\\n required.add_argument(\\n \\\"--outdir\\\", required=True, metavar=\\\"<dir>\\\", help=\\\"Output directory.\\\"\\n )\\n required.add_argument(\\n \\\"--ref-build\\\", required=True, metavar=\\\"<version>\\\", help=\\n \\\"Reference genome build, e.g. hg19 or mm10. Assuming the existence of \\\"\\n \\\"the 3 following files in <--ref-genome-dir>: <ref build>.fa \\\"\\n \\\"<ref build>.fa.fai and <ref build>.fa.dict\\\"\\n )\\n required.add_argument(\\n \\\"--ref-genome-dir\\\", metavar=\\\"<dir>\\\", help=\\n \\\"Bisulfite reference genome directory, including '<ref build>.fa', \\\"\\n \\\"'<ref build>.fa.fai', '<ref build>.fa.dict' and the \\\"\\n \\\"'Bisulfite_Genome' directory created by running the \\\"\\n \\\"'bismark_genome_preparation' script. See README.md documentation.\\\"\\n )\\n\\n\\n # Optional general arguments\\n optional = parser.add_argument_group(\\\"Optional\\\")\\n optional.add_argument(\\n \\\"--single-end\\\", action=\\\"store_false\\\", dest=\\\"paired_end\\\", help=\\n \\\"By default paired-end sequencing is assumed, for single-end set this \\\"\\n \\\"flag.\\\"\\n )\\n optional.add_argument(\\n \\\"--rrbs\\\", action=\\\"store_true\\\", help=\\n \\\"For Reduced Representation Bisulfite Sequencing (RRBS) set this flag.\\\"\\n )\\n optional.add_argument(\\n \\\"--no-deduplication\\\", action=\\\"store_false\\\",\\n dest=\\\"use_bismark_deduplicate\\\", help=\\n \\\"Set this flag to not apply Bismark BAM deduplication. The deduplica\\\"\\n \\\"tion removes reads with similar start/end positions on a given chromo\\\"\\n \\\"some. It is not a valid PCR correction for RRBS or amplicon data. \\\"\\n \\\"The deduplication is not applied if the --rrbs flag is set.\\\"\\n )\\n optional.add_argument(\\n \\\"--non-directional-library\\\", action=\\\"store_false\\\",\\n dest=\\\"directional_library\\\", help=\\n \\\"By default the library is assumed to be directional, if not set this \\\"\\n \\\"flag. See Bismark documentation for more information.\\\"\\n )\\n optional.add_argument(\\n \\\"--target-bed\\\", type=is_file, metavar=\\\"<path>\\\", help=\\n \\\"For targeted sequencing, the path to the BED file listing the regions\\\"\\n \\\" targeted. Used only for read coverage computation. If no BED is pro\\\"\\n \\\"vided the coverage will be computed on the whole reference genome.\\\"\\n )\\n optional.add_argument(\\n \\\"--target-kit\\\", metavar=\\\"<name>\\\", help=\\n \\\"For targeted sequencing, the name of the kit used to target to be \\\"\\n \\\"reported in the preprocessing report. Does not affect processing.\\\"\\n )\\n optional.add_argument(\\n \\\"--phred\\\", type=int, choices={33, 64}, default=DEFAULT_OF[\\\"phred\\\"],\\n metavar=\\\"<33|64>\\\", help=\\n \\\"Base quality encoding of input FASTQ files: 33|64, by default %i.\\\"\\n % DEFAULT_OF[\\\"phred\\\"]\\n )\\n optional.add_argument(\\n \\\"--r1-id\\\", default=DEFAULT_OF[\\\"r1_id\\\"], metavar=\\\"<ID>\\\", help=\\n \\\"Case-insensitive ID used to identify R1 (forward) reads in paired-end\\\"\\n \\\" sequencing, by default '%s'.\\\" % DEFAULT_OF[\\\"r1_id\\\"]\\n )\\n optional.add_argument(\\n \\\"--r2-id\\\", default=DEFAULT_OF[\\\"r2_id\\\"], metavar=\\\"<ID>\\\", help=\\n \\\"Case-insensitive ID used to identify R2 (reverse) reads in paired-end\\\"\\n \\\" sequencing, by default '%s'.\\\" % DEFAULT_OF[\\\"r2_id\\\"]\\n )\\n optional.add_argument(\\n \\\"--read-length\\\", type=int, metavar=\\\"<int>\\\", help=\\n \\\"Length of reads (e.g. 150) to write in the HTML report. \\\"\\n \\\"Does not affect the processing.\\\"\\n )\\n\\n # Optional FastQC arguments\\n fastqc = parser.add_argument_group(\\\"FastQC optional\\\")\\n optional.add_argument(\\n \\\"--fastqc-threads\\\", type=int, metavar=\\\"<int>\\\",\\n default=DEFAULT_OF[\\\"fastqc\\\"][\\\"threads\\\"], help=\\n \\\"FastQC '--threads' argument, by default %i.\\\"\\n % DEFAULT_OF[\\\"fastqc\\\"][\\\"threads\\\"]\\n )\\n\\n # Optional Trim Galore arguments\\n trim_galore = parser.add_argument_group(\\\"Trim Galore optional\\\")\\n ADAPTERS_URL = (\\n \\\"https://support.illumina.com/bulletins/2016/12/what-sequences-do-i\\\"\\n \\\"-use-for-adapter-trimming.html\\\")\\n trim_galore.add_argument(\\n \\\"--adapter-r1\\\", metavar=\\\"<sequence>\\\", help=\\n \\\"Trim Galore '--adapter' argument: adapter sequence to be trimmed off \\\"\\n \\\"read 1. Common sequences: %s\\\" % ADAPTERS_URL\\n )\\n trim_galore.add_argument(\\n \\\"--adapter-r2\\\", metavar=\\\"<sequence>\\\", help=\\n \\\"Trim Galore '--adapter2' argument: adapter sequence to be trimmed \\\"\\n \\\"off read 2. Common sequences: %s\\\" % ADAPTERS_URL\\n )\\n trim_galore.add_argument(\\n \\\"--quality\\\", type=int, default=DEFAULT_OF[\\\"trim_galore\\\"][\\\"quality\\\"],\\n metavar=\\\"<int>\\\", help=\\n \\\"Trim Galore '--quality' argument, by default %i.\\\"\\n % DEFAULT_OF[\\\"trim_galore\\\"][\\\"quality\\\"]\\n )\\n trim_galore.add_argument(\\n \\\"--stringency\\\", type=int, metavar=\\\"<int>\\\",\\n default=DEFAULT_OF[\\\"trim_galore\\\"][\\\"stringency\\\"], help=\\n \\\"Trim Galore '--stringency' argument: overlap with adapter sequence \\\"\\n \\\"required to trim, by default %i (very stringent).\\\"\\n % DEFAULT_OF[\\\"trim_galore\\\"][\\\"stringency\\\"]\\n )\\n trim_galore.add_argument(\\n \\\"--min-length\\\", type=int, metavar=\\\"<int>\\\",\\n default=DEFAULT_OF[\\\"trim_galore\\\"][\\\"min_length\\\"], help=\\n \\\"Trim Galore '--length' argument: minimum read length after trimming \\\"\\n \\\"otherwise removed, by default %i.\\\"\\n % DEFAULT_OF[\\\"trim_galore\\\"][\\\"min_length\\\"]\\n )\\n trim_galore.add_argument(\\n \\\"--error-rate\\\", type=float, metavar=\\\"<float>\\\",\\n default=DEFAULT_OF[\\\"trim_galore\\\"][\\\"error_rate\\\"], help=\\n \\\"Trim Galore '-e' argument: maximum allowed error rate with the \\\"\\n \\\"matching region, by default {}\\\"\\n .format(DEFAULT_OF[\\\"trim_galore\\\"][\\\"error_rate\\\"])\\n )\\n trim_galore.add_argument(\\n \\\"--max-n\\\", type=int, metavar=\\\"<int>\\\", help=\\n \\\"Trim Galore '--max_n' argument: Maximum number of 'N's in a read \\\"\\n \\\"otherwise removed. By default not applied.\\\"\\n )\\n trim_galore.add_argument(\\n \\\"--trim-n\\\", action=\\\"store_true\\\", help=\\n \\\"Trim Galore '--trim-n' argument: remove 'N's from ends of the read.\\\"\\n )\\n trim_galore.add_argument(\\n \\\"--clip-r1-5p\\\", type=int, metavar=\\\"<int>\\\", help=\\n \\\"Trim Galore '--clip_R1' argument: remove basepairs from 5' end of \\\"\\n \\\"read 1. Useful if there is a methylation bias at this end.\\\"\\n )\\n trim_galore.add_argument(\\n \\\"--clip-r2-5p\\\", type=int, metavar=\\\"<int>\\\", help=\\n \\\"Trim Galore '--clip_R2' argument: remove basepairs from 5' end of \\\"\\n \\\"read 2. Useful if there is a methylation bias at this end.\\\"\\n )\\n trim_galore.add_argument(\\n \\\"--clip-r1-3p\\\", type=int, metavar=\\\"<int>\\\", help=\\n \\\"Trim Galore '--three_prime_clip_R1' argument: remove basepairs from \\\"\\n \\\"3' end of read 1. Useful if there is a methylation bias at this end.\\\"\\n )\\n trim_galore.add_argument(\\n \\\"--clip-r2-3p\\\", type=int, metavar=\\\"<int>\\\", help=\\n \\\"Trim Galore '--three_prime_clip_R2' argument: remove basepairs from \\\"\\n \\\"3' end of read 2. Useful if there is a methylation bias at this end.\\\"\\n )\\n\\n # Optional Bismark tools arguments\\n bismark = parser.add_argument_group(\\\"Bismark optional\\\")\\n bismark.add_argument(\\n \\\"--seed-mismatch\\\", type=int, choices=[0, 1], metavar=\\\"<0|1>\\\",\\n default=DEFAULT_OF[\\\"bismark_bowtie2\\\"][\\\"seed_mismatch\\\"], help=\\n \\\"Maximum number of mismatch allowed in a seed alignment: 0|1, \\\"\\n \\\"by default %i.\\\" % DEFAULT_OF[\\\"bismark_bowtie2\\\"][\\\"seed_mismatch\\\"]\\n )\\n bismark.add_argument(\\n \\\"--bowtie2-threads\\\", type=int, metavar=\\\"<int>\\\",\\n default=DEFAULT_OF[\\\"bismark_bowtie2\\\"][\\\"threads\\\"], help=\\n \\\"Bowtie2 '--threads' argument, by default %i\\\"\\n % DEFAULT_OF[\\\"bismark_bowtie2\\\"][\\\"threads\\\"])\\n bismark.add_argument(\\n \\\"--meth-extract-threads\\\", type=int, metavar=\\\"<int>\\\",\\n default=DEFAULT_OF[\\\"bismark_meth_extract\\\"][\\\"threads\\\"], help=\\n \\\"bismark_methylation_extractor '--multicore' argument, by default %i.\\\"\\n % DEFAULT_OF[\\\"bismark_meth_extract\\\"][\\\"threads\\\"]\\n )\\n\\n # Optional Picard arguments\\n picard = parser.add_argument_group(\\\"Picard optional\\\")\\n picard.add_argument(\\n \\\"--picard-jvm-args\\\", default=DEFAULT_OF[\\\"picard\\\"][\\\"jvm_args\\\"],\\n metavar=\\\"<args>\\\", help=\\n \\\"Java virtual machine arguments, e.g. to control starting and maximum \\\"\\n \\\"heap size when running Picard, by default '%s'.\\\"\\n % DEFAULT_OF[\\\"picard\\\"][\\\"jvm_args\\\"]\\n )\\n\\n # Optional Samtools arguments\\n samtools = parser.add_argument_group(\\\"Samtools optional\\\")\\n samtools.add_argument(\\n \\\"--samtools-threads\\\", type=int, metavar=\\\"<int>\\\",\\n default=DEFAULT_OF[\\\"samtools\\\"][\\\"threads\\\"], help=\\n \\\"Samtools '--threads' argument, by default %i\\\"\\n % DEFAULT_OF[\\\"samtools\\\"][\\\"threads\\\"])\\n\\n # Parse the command line\\n args = parser.parse_args()\\n\\n # For paired-end sequencing, check that the '{end}' wildcard is provided\\n if args.paired_end is True and \\\"{end}\\\" not in args.fastq_regex:\\n raise ValueError(\\n \\\"The wildcard '{end}' is required in --fastq-regex argument when \\\"\\n \\\"working with paired-end sequencing.\\\")\\n\\n # Set 'use_bismark_deduplicate' to False if RRBS data\\n if args.rrbs is True:\\n args.use_bismark_deduplicate = False\\n\\n # Check reference genome directory\\n is_ref_genome_dir(args.ref_genome_dir, args.ref_build)\\n\\n # Convert the argparse object to a dict mapping <arg name> -> <val>\\n kwargs = vars(args)\\n\\n return kwargs\",\n \"def parse_cmdline():\\n\\tparser = ArgumentParser(prog=\\\"FastP_QC.py\\\", description=\\\"\\\"\\\"Script collects stats from fastp jsons.\\\"\\\"\\\")\\n\\tparser.add_argument(\\\"-r1\\\", \\\"--r1_stats\\\", dest=\\\"r1_stats\\\", action=\\\"store\\\", required=True, help=\\\"Text file with r1 stats, from q30.py script.\\\")\\n\\tparser.add_argument(\\\"-r2\\\", \\\"--r2_stats\\\", dest=\\\"r2_stats\\\", action=\\\"store\\\", required=True, help=\\\"Text file with r2 stats, from q30.py script.\\\")\\n\\tparser.add_argument(\\\"-n\\\", \\\"--name\\\", dest=\\\"name\\\", action=\\\"store\\\", required=True, help=\\\"Sample name\\\")\\n\\targs = parser.parse_args()\\n\\treturn args\",\n \"def parse_command_line():\\r\\n\\r\\n parser = argparse.ArgumentParser(description='User args')\\r\\n parser.add_argument(\\\"--action\\\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\\\"Choose action.\\\")\\r\\n parser.add_argument(\\\"--model\\\", choices=['vgg', 'unet', 'fpn'], required=True, help=\\\"Choose model.\\\")\\r\\n parser.add_argument(\\\"--dataset\\\", choices=['full', 'small'], required=True, help=\\\"Choose dataset.\\\")\\r\\n\\r\\n return parser.parse_args()\",\n \"def parse_parameters():\\n parser = argparse.ArgumentParser(description='Program that checks for bad evaluations.')\\n parser.usage = 'bettercorrectors [-h] client_id client_secret start_date [end_date] [--sql file]'\\n parser.add_argument('client_id', help='the client_id of your intranet application', type=str)\\n parser.add_argument('client_secret', help='the client_secret of your intra application', type=str)\\n parser.add_argument('start_date', help='the latest date in iso format', type=datetime.fromisoformat)\\n parser.add_argument('end_date', help='the closest date in iso format (optional)', type=datetime.fromisoformat,\\n default=datetime.now(), nargs='?')\\n parser.add_argument('--sql', dest='file', help='''name of the database file in case you want to save results in a \\n sqlite database''', type=str)\\n args = parser.parse_args()\\n return args\",\n \"def usage(progname):\\n sys.stderr.write(\\\"usage: \\\" + progname + \\n \\\" [-s id_list] [-i] [-t]\\\\n\\\"\\n \\\" [-p preiviously_built_list]\\\\n\\\"\\n \\\" [-g potential_upgrades_list]\\\\n\\\"\\n \\\" [-u subsets_tap_stderr_file]\\\\n\\\"\\n \\\" mods_file nochange_vht_file invidual_tap_stderr_file \\\"\\n \\\"pairwise_tap_stderr_file budget\\\\n\\\")\\n sys.stderr.write(\\\" -i : round all values to integer\\\\n\\\")\\n sys.stderr.write(\\\" -s id_list : subsets of ids in id_list only\\\\n\\\")\\n sys.stderr.write(\\\" -t timeperiod: add time period, intersrate to dzn\\\\n\\\")\\n sys.stderr.write(\\\" -u substs_tap_stderr_file: data for triples also\\\\n\\\")\\n sys.stderr.write(\\\" -p preiouvlys_built_list: list of previously built upgrades\\\\n\\\")\\n sys.stderr.write(\\\" -g potential_upgrades_list: list of potenti upgrades to consider\\\\n\\\")\\n sys.exit(1)\",\n \"def parse_command_line(self, argv):\\n from optparse import OptionParser\\n usage = \\\"usage: %prog [options]\\\"\\n parser = OptionParser(usage)\\n\\n (options, args) = parser.parse_args(argv)\",\n \"def parsingcommands(self):\\n parser = argparse.ArgumentParser(\\n description=\\\"httpfs is a simple file server.\\\")\\n parser.add_argument(\\\"-v\\\", action=\\\"store_true\\\", dest=\\\"debug\\\",\\n help=\\\"Prints debugging messages.\\\", default=False)\\n parser.add_argument(\\\"-p\\\", action=\\\"store\\\", dest=\\\"port\\\",\\n help=\\\"Specifies the port number that the server will listen and serve at. Default is 8080.\\\",\\n type=int, default=8080)\\n parser.add_argument(\\\"-d\\\", action=\\\"store\\\", dest=\\\"path_to_dir\\\",\\n help=\\\"Specifies the directory that the server will use to read/writerequested files. \\\\\\n Default is the current directory when launching theapplication.\\\",\\n default='./')\\n parser.add_argument(\\\"-arq\\\", action='store_true', dest=\\\"arq\\\", default=False, help=\\\"Automatic-Repeat-Request (ARQ)\\\")\\n\\n return parser.parse_args()\",\n \"def _read_cmd_args():\\n\\n # Check if argument count is correct.\\n if len(sys.argv) != 5:\\n print(\\\"[ERR] Invalid number of command line arguments!\\\")\\n _usage()\\n sys.exit(1)\\n\\n # Get path to config file\\n configfile = sys.argv[1]\\n if not os.path.exists(configfile):\\n print(f\\\"[ERR] Config file {configfile} does not exist!\\\")\\n sys.exit(1)\\n\\n # Get top directory of LIS data\\n topdatadir = sys.argv[2]\\n if not os.path.exists(topdatadir):\\n print(f\\\"[ERR] LIS data directory {topdatadir} does not exist!\\\")\\n sys.exit(1)\\n\\n # Get valid year and month\\n yyyymm = sys.argv[3]\\n if len(yyyymm) != 6:\\n print(\\\"[ERR] Invalid length of YYYYMM, must be 6 characters!\\\")\\n sys.exit(1)\\n year = int(yyyymm[0:4])\\n month = int(yyyymm[4:6])\\n try:\\n startdate = datetime.datetime(year, month, day=1)\\n except ValueError:\\n print(\\\"[ERR] Invalid YYYYMM passed to script!\\\")\\n sys.exit(1)\\n\\n # Get model forcing ID\\n model_forcing = sys.argv[4]\\n\\n return configfile, topdatadir, startdate, model_forcing\",\n \"def main():\\r\\n args = sys.argv\\r\\n print 'Script:', args[0]\\r\\n args.pop(0)\\r\\n for i, argument in enumerate(sys.argv):\\r\\n print 'Argument {}: {}'.format(i, argument)\\r\\n print 'Type: {}'.format(type(argument))\",\n \"def read_cmd_args():\\n\\n if len(sys.argv) != 9:\\n print(\\\"[ERR] Invalid number of command line arguments!\\\")\\n usage()\\n sys.exit(1)\\n\\n # FCST_SYR\\n try:\\n fcst_syr = int(sys.argv[1])\\n except ValueError:\\n print(f\\\"[ERR] Invalid argument for FCST_SYR! Received {(sys.argv[1])}\\\")\\n usage()\\n sys.exit(1)\\n if fcst_syr < 0:\\n print(f\\\"[ERR] Invalid argument for FCST_SYR! Received {(sys.argv[1])}\\\")\\n usage()\\n sys.exit(1)\\n\\n # FCST_EYR\\n try:\\n fcst_eyr = int(sys.argv[2])\\n except ValueError:\\n print(f\\\"[ERR] Invalid argument for FCST_EYR! Received {(sys.argv[2])}\\\")\\n usage()\\n sys.exit(1)\\n if fcst_eyr < 0:\\n print(f\\\"[ERR] Invalid argument for FCST_EYR! Received {(sys.argv[2])}\\\")\\n usage()\\n sys.exit(1)\\n\\n # MONTH_ABBR\\n month_abbr = str(sys.argv[3])\\n\\n # MONTH_NUM\\n try:\\n month_num = int(sys.argv[4])\\n except ValueError:\\n print(f\\\"[ERR] Invalid argument for MONTH_NUM! Received {(sys.argv[4])}\\\")\\n usage()\\n sys.exit(1)\\n if month_num < 1:\\n print(f\\\"[ERR] Invalid argument for MONTH_NUM! Received {(sys.argv[4])}\\\")\\n usage()\\n sys.exit(1)\\n if month_num > 12:\\n print(f\\\"[ERR] Invalid argument for MONTH_NUM! Received {(sys.argv[4])}\\\")\\n usage()\\n sys.exit(1)\\n\\n # FCST_TYPE\\n fcst_type = str(sys.argv[5])\\n\\n # LEAD_MONTHS\\n try:\\n lead_months = int(sys.argv[6])\\n except ValueError:\\n print(f\\\"[ERR] Invalid argument for LEAD_MONTHS! Received {(sys.argv[6])}\\\")\\n usage()\\n sys.exit(1)\\n if lead_months < 0:\\n print(f\\\"[ERR] Invalid argument for LEAD_MONTHS! Received {(sys.argv[6])}\\\")\\n usage()\\n sys.exit(1)\\n\\n # ENS_NUM\\n try:\\n ens_num = int(sys.argv[7])\\n except ValueError:\\n print(f\\\"[ERR] Invalid argument for ENS_NUM! Received {(sys.argv[7])}\\\")\\n usage()\\n sys.exit(1)\\n if ens_num < 0:\\n print(f\\\"[ERR] Invalid argument for ENS_NUM! Received {(sys.argv[7])}\\\")\\n usage()\\n sys.exit(1)\\n\\n # CONFIG_FILE\\n config_file = sys.argv[8]\\n if not os.path.exists(config_file):\\n print(f\\\"[ERR] {config_file} does not exist!\\\")\\n sys.exit(1)\\n\\n return fcst_syr, fcst_eyr, month_abbr, month_num, fcst_type, lead_months, \\\\\\n \\tens_num, config_file\",\n \"def usage():\\n print(\\\"Usage:\\\\n python NFLplayerSentiments.py 'QUERY' (remember to include the quotes).\\\")\",\n \"def main():\\n\\n # If wrong number of arguments \\n if len(sys.argv) == 1 or len(sys.argv) > 2:\\n help()\\n return\\n \\n # Otherwise pop out the command\\n command = sys.argv.pop()\\n\\n # Test for which command\\n if command == \\\"version\\\":\\n version()\\n elif command == \\\"help\\\":\\n help()\\n elif command == \\\"init\\\":\\n init()\\n elif command == \\\"make\\\":\\n make()\\n elif command == \\\"upload\\\":\\n upload()\",\n \"def usage():\\n\\n if len(sys.argv) != 3:\\n print \\\"Usage: ./dnsclient.py <DNS name/IP> <query type>\\\"\\n exit(0)\",\n \"def setup_cmd_args():\\n parser = argparse.ArgumentParser(description=\\\"This program will query G-POD and COPHUB on the same datasets, in order to obtain the number of data results, compare them compile a report with the differences.\\\", formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n # parser.add_argument(\\\"root_dir\\\", help=\\\"The root directory containing data to check\\\")\\n # parser.add_argument(\\\"--workspace\\\", help=\\\"Set Workspace manually\\\")\\n parser.add_argument(\\\"--outputlist\\\", help=\\\"Folder to write the output lists with the un-synced products.\\\", default=\\\"c:\\\\\\\\temp\\\\\\\\\\\")\\n parser.add_argument(\\\"--daysback\\\", help=\\\"Report with a given number of days back from today\\\", default=0)\\n parser.add_argument(\\\"--dataset\\\", help=\\\"Set which dataset to query (chose S3A_SR_1_SRA_A_PREOPS or S3B_SR_1_SRA_A_NTC)\\\")\\n parser.add_argument(\\\"--startdate\\\", help=\\\" The Start Date (format: YYYY-MM-DD) \\\", default=\\\"2016-06-01\\\")\\n parser.add_argument(\\\"--enddate\\\",help=\\\" The End Date (format: YYYY-MM-DD)\\\")\\n parser.add_argument(\\\"--cphubuser\\\",help=\\\"COPHUB username\\\", required=True)\\n parser.add_argument(\\\"--cphubpw\\\",help=\\\"COPHUB password\\\", required=True)\\n parser.add_argument(\\\"-email\\\", type=str, help=\\\"Email to send the results\\\", action=\\\"append\\\")\\n parser.add_argument('-t', action='store_true', help=\\\"Today as enddate. Otherwise the last day of the previous month is considered.\\\")\\n parser.add_argument('-n', action='store_true', help=\\\"Normal numeric check\\\")\\n parser.add_argument('-m', action='store_true', help=\\\"Monthly check with product listing.\\\")\\n return parser.parse_args()\",\n \"def parse_cmdline(argv):\\n if argv is None:\\n argv = sys.argv[1:]\\n\\n # initialize the parser object:\\n parser = argparse.ArgumentParser(description='Changes a lammps data file by implementing options such as: '\\n 'reorder atom ids in a lammps data file, given a dictionary to '\\n 'reorder the atoms (a csv of old_index,new_index), and/or '\\n 'change the atom, bond, angle, dihedral, and/or improper types,'\\n 'given a dictionary to do so. Can also '\\n 'print info for selected atom ids. ')\\n parser.add_argument(\\\"-c\\\", \\\"--config\\\", help=\\\"The location of the configuration file in ini format.\\\"\\n \\\"The default file name is {}, located in the \\\"\\n \\\"base directory where the program as run.\\\".format(DEF_CFG_FILE),\\n default=DEF_CFG_FILE, type=read_cfg)\\n args = None\\n try:\\n args = parser.parse_args(argv)\\n except IOError as e:\\n warning(\\\"Problems reading file:\\\", e)\\n parser.print_help()\\n return args, IO_ERROR\\n except (InvalidDataError, KeyError, MissingSectionHeaderError, SystemExit) as e:\\n if hasattr(e, 'code') and e.code == 0:\\n return args, GOOD_RET\\n warning(e)\\n parser.print_help()\\n return args, INPUT_ERROR\\n return args, GOOD_RET\",\n \"def usage(arg):\\r\\n\\r\\n logging.debug('usage({})'.format(arg))\\r\\n\\r\\n myDocstring = \\\"\\\"\\r\\n if arg in [\\\"-i\\\", \\\"--info\\\"]:\\r\\n myDocstring = myDocstring+\\\"\\\\n\\\"+__doc__\\r\\n myDocstring = myDocstring+\\\"\\\\n AUTHOR\\\\n\\\\n $author$\\\\n\\\"\\r\\n myDocstring = myDocstring+\\\"\\\\n LICENSE\\\\n\\\\n $license$\\\\n\\\"\\r\\n parser.print_help()\\r\\n elif arg in [\\\"-v\\\", \\\"-i\\\", \\\"--version\\\", \\\"--info\\\"]:\\r\\n myDocstring = myDocstring+\\\"\\\\n VERSION\\\\n\\\\n $version$\\\\n\\\" \\r\\n myDocstring = myDocstring.replace('$version$', __version__)\\r\\n myDocstring = myDocstring.replace('$author$',__author__)\\r\\n myDocstring = myDocstring.replace('$license$',__license__)\\r\\n print(myDocstring)\",\n \"def test_cli_help(run):\\n msg = []\\n _, err = run(dork.cli.the_predork_cli, msg, *(\\\"\\\", \\\"-h\\\"))\\n assert \\\"usage: \\\" in msg[0], \\\\\\n \\\"Failed to run the cli.main method: {err}\\\".format(err=err)\",\n \"def usage():\\n\\tprint()\\n\\tprint(\\n\\t\\t'\\\\t Usage: python conos_aicuu_client.py [-h] [--help] <ENDPOINT> <ENVIRONMENT> <CLIENT_ID> <CLIENT_SECRET> <INPUT_FILE> <OUTPUT_FILE> <NUMBER_THREAD>')\\n\\tprint('\\\\t -h : help')\\n\\tprint('\\\\t ENDPOINT : 1: /v1.0/person')\\n\\tprint('\\\\t 2: /v1.0/company')\\n\\tprint('\\\\t ENVIRONMENT : must be one of: dev, test, int, prod')\\n\\tprint('\\\\t CLIENT_ID : used for obtaining access token')\\n\\tprint('\\\\t CLIENT_SECRET : used for obtaining access token')\\n\\tprint('\\\\t INPUT_FILE : location of the request input file')\\n\\tprint('\\\\t OUTPUT_FILE : location of the output file (analyze report)')\\n\\tprint('\\\\t NUMBER_THREAD : (optional) number of threads to process data (from 1 -> 8, default is 1)')\\n\\tprint('\\\\n\\\\t Example : python conos_aicuu_client.py 1 test Admin 123456 data/person/input.txt data/person/output.txt 5')\\n\\texit(2)\",\n \"def test_explicit_usage_message(self):\\n assert 'Usage:' in main('coloredlogs', '--help', capture=True)\",\n \"def make_parser():\\n parser_ = argparse.ArgumentParser(\\n description=\\\"\\\"\\\"\\n A tool to retrieve history from\\n (almost) any browser on (almost) any platform\\n\\n██████╗ ██████╗ ██████╗ ██╗ ██╗███████╗███████╗██████╗ ██╗ ██╗██╗███████╗████████╗ ██████╗ ██████╗ ██╗ ██╗\\n██╔══██╗██╔══██╗██╔═══██╗██║ ██║██╔════╝██╔════╝██╔══██╗ ██║ ██║██║██╔════╝╚══██╔══╝██╔═══██╗██╔══██╗╚██╗ ██╔╝\\n██████╔╝██████╔╝██║ ██║██║ █╗ ██║███████╗█████╗ ██████╔╝█████╗███████║██║███████╗ ██║ ██║ ██║██████╔╝ ╚████╔╝\\n██╔══██╗██╔══██╗██║ ██║██║███╗██║╚════██║██╔══╝ ██╔══██╗╚════╝██╔══██║██║╚════██║ ██║ ██║ ██║██╔══██╗ ╚██╔╝\\n██████╔╝██║ ██║╚██████╔╝╚███╔███╔╝███████║███████╗██║ ██║ ██║ ██║██║███████║ ██║ ╚██████╔╝██║ ██║ ██║\\n╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚══╝╚══╝ ╚══════╝╚══════╝╚═╝ ╚═╝ ╚═╝ ╚═╝╚═╝╚══════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝\\n \\\"\\\"\\\", # noqa: E501\\n epilog=\\\"\\\"\\\"\\n Checkout the GitHub repo\\n https://github.com/pesos/browser-history\\n if you have any issues or want to help contribute\\\"\\\"\\\",\\n formatter_class=RawDescriptionHelpFormatter,\\n )\\n\\n parser_.add_argument(\\n \\\"-t\\\",\\n \\\"--type\\\",\\n default=\\\"history\\\",\\n help=f\\\"\\\"\\\"\\n argument to decide whether to retrieve history or bookmarks.\\n Should be one of {AVAILABLE_TYPES}.\\n Default is history.\\\"\\\"\\\",\\n )\\n parser_.add_argument(\\n \\\"-b\\\",\\n \\\"--browser\\\",\\n default=\\\"all\\\",\\n help=f\\\"\\\"\\\"\\n browser to retrieve history or bookmarks from. Should be one\\n of all, default, {AVAILABLE_BROWSERS}.\\n Default is all (gets history or bookmarks from all browsers).\\n \\\"\\\"\\\",\\n )\\n\\n parser_.add_argument(\\n \\\"-f\\\",\\n \\\"--format\\\",\\n default=\\\"infer\\\",\\n help=f\\\"\\\"\\\"\\n Format to be used in output. Should be one of {AVAILABLE_FORMATS}.\\n Default is infer (format is inferred from the output file's\\n extension. If no output file (-o) is specified, it defaults to csv)\\\"\\\"\\\",\\n )\\n\\n parser_.add_argument(\\n \\\"-o\\\",\\n \\\"--output\\\",\\n default=None,\\n help=\\\"\\\"\\\"\\n File where history output or bookmark output is to be written.\\n If not provided, standard output is used.\\\"\\\"\\\",\\n )\\n\\n parser_.add_argument(\\n \\\"-p\\\",\\n \\\"--profile\\\",\\n default=None,\\n help=\\\"\\\"\\\"\\n Specify the profile from which to fetch history or bookmarks. If\\n not provided all profiles are fetched\\n \\\"\\\"\\\",\\n )\\n\\n parser_.add_argument(\\n \\\"--show-profiles\\\",\\n default=None,\\n metavar=\\\"BROWSER\\\",\\n help=f\\\"\\\"\\\"\\n List all available profiles for a given browser where browser\\n can be one of default, {AVAILABLE_BROWSERS}. The browser\\n must always be provided.\\n \\\"\\\"\\\",\\n )\\n\\n parser_.add_argument(\\n \\\"-v\\\", \\\"--version\\\", action=\\\"version\\\", version=\\\"%(prog)s \\\" + __version__\\n )\\n\\n return parser_\",\n \"def cmd_help(args):\",\n \"def display_usage():\\n print >> sys.stderr, __doc__\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Sets up package within the pheeno's directory.\\\"\\n )\\n\\n # Required arguments\\n parser.add_argument(\\\"-x\\\", \\\"--execute\\\", action=\\\"execute\\\", required=True,\\n help=\\\"something\\\", default=False)\\n\\n # Optional arguments\\n parser.add_argument(\\\"-s\\\", \\\"--save\\\", action=\\\"store\\\", required=False,\\n help=\\\"something\\\", default=False)\",\n \"def hotfix_deepobs_argparse():\\n sys.argv = sys.argv[:1]\",\n \"def parse_args(self, argv, env=None):\\n env = env or os.environ\\n self.argv = argv\\n self.parser = HelpfulArgumentParser(add_help=False)\\n self.parser.add_argument(\\n '--help',\\n action='store_true',\\n help='prints usage information for the awx tool',\\n )\\n self.parser.add_argument(\\n '--version',\\n dest='conf.version',\\n action='version',\\n help='display awx CLI version',\\n version=__version__\\n )\\n add_authentication_arguments(self.parser, env)\\n add_output_formatting_arguments(self.parser, env)\\n\\n self.args = self.parser.parse_known_args(self.argv)[0]\\n self.verbose = self.get_config('verbose')\\n if self.verbose:\\n logging.basicConfig(level='DEBUG')\\n self.color = self.get_config('color')\\n if not self.color:\\n disable_color()\\n fmt = self.get_config('format')\\n if fmt not in FORMATTERS.keys():\\n self.parser.error('No formatter %s available.' % (fmt))\",\n \"def usage():\\n print 'cpp file Generator.'\\n print 'Usage:'\\n print ' -h: help'\\n print ' -i: file'\\n print ' --help: help'\\n print ' --in: help'\\n sys.exit(1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6791781","0.6728012","0.6684721","0.66259867","0.65740335","0.65634924","0.651287","0.6476925","0.64419854","0.6423106","0.64119226","0.6408889","0.6356593","0.6337435","0.6331671","0.63285047","0.6319351","0.6319351","0.63117146","0.62988","0.62978756","0.62975425","0.62929803","0.62854123","0.6261513","0.6252085","0.62444854","0.62340766","0.62226534","0.6211405","0.62096626","0.61881655","0.61854404","0.61666656","0.616244","0.61596084","0.6157386","0.6157386","0.61416095","0.6129979","0.61194813","0.60805845","0.607386","0.6065788","0.60643667","0.6060954","0.60445774","0.6037937","0.6035148","0.6031834","0.60286915","0.60280067","0.60229033","0.60058606","0.5982882","0.59730273","0.59729147","0.5962144","0.59574014","0.5935328","0.5935288","0.5931674","0.5930592","0.5927342","0.5924878","0.59237593","0.59228593","0.59198433","0.59194034","0.59178054","0.59167504","0.5909184","0.59006375","0.5886608","0.5886192","0.58842313","0.5881682","0.58793944","0.58787376","0.5876088","0.58746195","0.5871688","0.5865828","0.58643854","0.5857434","0.5856166","0.58539015","0.58496386","0.5847946","0.58474743","0.584529","0.5844315","0.5833319","0.58289576","0.58279175","0.5825218","0.58139575","0.5811282","0.5808656","0.5807828","0.58076763"],"string":"[\n \"0.6791781\",\n \"0.6728012\",\n \"0.6684721\",\n \"0.66259867\",\n \"0.65740335\",\n \"0.65634924\",\n \"0.651287\",\n \"0.6476925\",\n \"0.64419854\",\n \"0.6423106\",\n \"0.64119226\",\n \"0.6408889\",\n \"0.6356593\",\n \"0.6337435\",\n \"0.6331671\",\n \"0.63285047\",\n \"0.6319351\",\n \"0.6319351\",\n \"0.63117146\",\n \"0.62988\",\n \"0.62978756\",\n \"0.62975425\",\n \"0.62929803\",\n \"0.62854123\",\n \"0.6261513\",\n \"0.6252085\",\n \"0.62444854\",\n \"0.62340766\",\n \"0.62226534\",\n \"0.6211405\",\n \"0.62096626\",\n \"0.61881655\",\n \"0.61854404\",\n \"0.61666656\",\n \"0.616244\",\n \"0.61596084\",\n \"0.6157386\",\n \"0.6157386\",\n \"0.61416095\",\n \"0.6129979\",\n \"0.61194813\",\n \"0.60805845\",\n \"0.607386\",\n \"0.6065788\",\n \"0.60643667\",\n \"0.6060954\",\n \"0.60445774\",\n \"0.6037937\",\n \"0.6035148\",\n \"0.6031834\",\n \"0.60286915\",\n \"0.60280067\",\n \"0.60229033\",\n \"0.60058606\",\n \"0.5982882\",\n \"0.59730273\",\n \"0.59729147\",\n \"0.5962144\",\n \"0.59574014\",\n \"0.5935328\",\n \"0.5935288\",\n \"0.5931674\",\n \"0.5930592\",\n \"0.5927342\",\n \"0.5924878\",\n \"0.59237593\",\n \"0.59228593\",\n \"0.59198433\",\n \"0.59194034\",\n \"0.59178054\",\n \"0.59167504\",\n \"0.5909184\",\n \"0.59006375\",\n \"0.5886608\",\n \"0.5886192\",\n \"0.58842313\",\n \"0.5881682\",\n \"0.58793944\",\n \"0.58787376\",\n \"0.5876088\",\n \"0.58746195\",\n \"0.5871688\",\n \"0.5865828\",\n \"0.58643854\",\n \"0.5857434\",\n \"0.5856166\",\n \"0.58539015\",\n \"0.58496386\",\n \"0.5847946\",\n \"0.58474743\",\n \"0.584529\",\n \"0.5844315\",\n \"0.5833319\",\n \"0.58289576\",\n \"0.58279175\",\n \"0.5825218\",\n \"0.58139575\",\n \"0.5811282\",\n \"0.5808656\",\n \"0.5807828\",\n \"0.58076763\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12878,"cells":{"query":{"kind":"string","value":"Return df with all enteries which df.query(pattern) match with removed"},"document":{"kind":"string","value":"def remove(df, pattern):\n return df[~df.index.isin(df.query(pattern).index)]"},"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 prune(df, regex_list):\n for regex_pattern in regex_list:\n df = df[~df.case_action.str.contains(regex_pattern)]\n return df","def clean(df):","def filter_same_helix(df):\n helixpattern = re.compile(r\"\"\"^(..)\\w+\\s+\\1\"\"\")#For detecting same-helix contacts, the ones like 1.22x22 1.54x54\n helixfilter = df['Position'].str.contains(helixpattern)\n df = df[~helixfilter]\n return(df)","def filter_processes(ps_df: pd.DataFrame, user_query: str) -> pd.DataFrame:\n user_query = user_query.strip('\\'')\n result_df = ps_df.query(user_query)\n return result_df","def pattern_search(pattern, dataset, column):\n # Filter\n dataset = dataset[dataset[column].str.contains(pattern, regex=True)]\n # Reset index\n dataset = dataset.reset_index(drop=True)\n # Return\n return dataset","def minus_df(df):\n return df[df[\"content\"].str.contains(\"(^|[^0-9])\\-[0-9]+\")]","def filter(df, predicate):\n if not df:\n return []\n\n return [row for row in df if predicate(row)]","def _filter_df(adjmat, df, verbose=3):\n remcols = df.columns[~np.isin(df.columns.values, adjmat.columns.values)].values\n if len(remcols)>0:\n if verbose>=3: print('[bnlearn] >Removing columns from dataframe to make consistent with DAG [%s]' %(remcols))\n df.drop(labels=remcols, axis=1, inplace=True)\n return df","def _filter_df(adjmat, df, verbose=3):\n remcols = df.columns[~np.isin(df.columns.values, adjmat.columns.values)].values\n if len(remcols)>0:\n if verbose>=3: print('[bnlearn] >Removing columns from dataframe to make consistent with DAG [%s]' %(remcols))\n df.drop(labels=remcols, axis=1, inplace=True)\n return df","def _clean_dataset(df: pd.DataFrame) -> pd.DataFrame:\n df = df.loc[:, ~df.columns.str.contains(\"^Unnamed\")]\n df = df.dropna()\n return df","def trimDf(df):\n cols = set(df.columns)\n\n cols.remove('exclamationCount') # bug in our feature extraction code\n cols.remove('price') # considered only free apps\n cols.remove('appName') # removing appNames\n\n # return df[list(cols)]\n\n\n\n return df[list(('revSent', 'appLabel'))]","def get_subtable(df, col, val) -> pd.DataFrame:\r\n return df[df[col] == val].drop(columns=col)","def remove_other_elements(data):\n charset = ['F','l','B','r','I','i','M','g','L','b','a','e','K','V','d','R','Z','G','A','Y','u']\n x = []\n for i in range(data.shape[0]):\n for j in range(len(data.iloc[i,1])):\n if data.iloc[i,1][j] in charset:\n x.append(i)\n break\n df = data[(True^data['Index'].isin(x))]\n df.reset_index(drop=True, inplace=True)\n return df","def clean(self):\n self.df = _data.prune(self.df, [REGEX_PATTERN_GCI, REGEX_PATTERN_DB_ID])\n self.df, _ = _data.remove_totally_failed_tests(self.df)\n self.is_cleaned = True","def filter_blacklist(df, path):\n f = open(path)\n patterns = [e.strip() for e in f.readlines()]\n f.close()\n\n def run_filter(x):\n for pat in patterns:\n if fnmatch.fnmatch(x, pat):\n return True\n return False\n\n index = df[df[PROD_NM].apply(run_filter)].index\n df.drop(columns=[PROD_NM], index=index, inplace=True)","def drop_irrelevant_practices(df):\n\n is_relevant = df.groupby(\"practice\").value.any()\n return df[df.practice.isin(is_relevant[is_relevant == True].index)]","def _remove_non_informative_rows(self, df, threshold):\n df_tmp = pd.DataFrame()\n n_features = len(df.columns)\n # calculating ratio of rows that have more than \"ratio\" missing values\n df_tmp['ratio'] = df.apply(lambda row: row.isnull().sum()/n_features, axis='columns')\n\n # kick too noisy rows\n return df[df_tmp['ratio'] <= threshold]","def cleanDf(df, badaa=None):\n return df.loc[[isvalidpeptide(s, badaa) for s in df.seq]]","def remove_rows_with_non_english_movies(df):\n df = df[df['original_language'] == 'en']\n return df","def clean_rows_cat_values(df: pd.DataFrame, col: str, values: list) -> pd.DataFrame:\n\n # create mask to filter df with rows that have\n # the indicated values in the indicated column\n index = df.columns.get_loc(col)\n mask = [df.iloc[row, index] not in values for row in range(len(df))]\n\n # print original dataframe shape\n print(f\"Shape of the original dataframe: \\n{df.shape}\\n\")\n\n # filter df\n df = df.iloc[mask]\n df.reset_index(drop=True, inplace=True)\n print(\n f\"Shape after removing rows with values equal to\\n{values}\\nin column '{col}'':\"\n )\n print(df.shape, \"\\n\")\n\n return df","def select_feats(df):\n cols = list(df)\n for col in cols:\n if col not in config[\"feats\"] and col != \"label\":\n df = df.drop(columns=col)\n return df","def clean_unknown(df, db, index_col='id'):\n ind = []\n for i, gene_id in enumerate(df[index_col]):\n try:\n db[gene_id]\n ind.append(i)\n except gffutils.FeatureNotFoundError:\n continue\n return df.ix[ind, :]","def filter_cols(df):\n comm_keys = list( set(df.keys()) & set(KEYS_FOR_ML) )\n filt_col_df = df.copy()[comm_keys]\n\n return filt_col_df","def remove_rows_without_feature(df, feature):\n return df[np.isfinite(df[feature])]","def deletingNaNs(df):\n # start_ time.time()\n df_old = df.copy()\n df.dropna(axis=1, how='any', inplace=True)\n for key in df_old:\n if str(key) not in df:\n print('Deleted ', key)\n # end_time time.time()\n #print('Time to run deletingNaNs: ', end_time - start_time)\n return df","def extract_relevant_rows(df, column_name, column_value, not_equal=False):\n\n if not_equal:\n return df.loc[df[column_name] != column_value]\n\n return df.loc[df[column_name] == column_value]","def filter_input(input_df, target_df):\n # input_df = input_df.reindex(target_df.index, copy=False)\n data_df = pd.concat((input_df, target_df), join=\"inner\", copy=False, axis=1)\n return data_df","def delete_matches(self, pattern):\n with self.connect() as c:\n cur = c.cursor()\n cur.execute(self.create_query(\"DELETE\", pattern))","def unmatching_driver_id(df):\n\ttemp = df[df['driver_id_bkg'].notnull()]\n\torder_ids = temp[temp['driver_id_bkg'] != temp['driver_id_pnt']]['order_id'].values\n\treturn df[~df['order_id'].isin(order_ids)]","def drop_transafers(df):\n return df.filter(~(df.valor == 0))","def data_cleaning(df):\n df = df.dropna(how='all')\n \n return df","def delete_problematic_entries(\n df: pd.DataFrame,\n members_no_address_at_all: Set,\n members_no_zipCity: Set,\n members_with_invalid_matrices: Set,\n) -> pd.DataFrame:\n members_to_delete = members_no_address_at_all.union(members_no_zipCity).union(\n members_with_invalid_matrices\n )\n\n df = df.loc[~df[\"memberid\"].isin(members_to_delete)]\n return df","def filter_by_match(df: pd.DataFrame, d: dict) -> np.ndarray:\n incl = np.ones([len(df)], dtype=bool)\n for k, v in d.items():\n incl = incl & (df[k] == v)\n return incl","def subset(self, *args, **kwargs):\n\t\tgs = copy.copy(self)\n\t\tqueryStrings = kwargs['queryStrings'] if 'queryStrings' in kwargs else args[0] if args else []\n\t\tif isinstance(queryStrings, str) or isinstance(queryStrings, bytes):\t# assume queryString was specified as a string\n\t\t\tqueryStrings = [queryStrings]\n\t\n\t\tif len(queryStrings)==0:\n\t\t\treturn gs\n\t\t\t\n\t\tdf = gs._dataframe\n\t\t\n\t\tif 'species' in kwargs and kwargs['species'] in ['MusMusculus','HomoSapiens']:\n\t\t\tdf = df[df['Species']==kwargs['species']]\n\t\t\t\n\t\tcaseSensitive = kwargs.get('caseSensitive', False)\n\t\tif not caseSensitive: queryStrings = [item.lower() for item in queryStrings]\n\t\t\n\t\tmatchSubstring = kwargs.get('matchSubstring', True)\n\t\t\n\t\t# determine which columns to search\n\t\tsearchColumns = kwargs.get('searchColumns')\n\t\tallColumns = ['EnsemblId','EntrezId','GeneSymbol','Synonyms','Description']\n\t\tif searchColumns:\n\t\t\tsearchColumns = ['EnsemblId' if item=='GeneId' or item=='geneId' else item for item in searchColumns]\n\t\tif searchColumns and len(set(allColumns).intersection(set(searchColumns)))>0:\n\t\t\tsearchColumns = list(set(allColumns).intersection(set(searchColumns)))\n\t\telse:\n\t\t\tsearchColumns = allColumns\n\t\t\n\t\trowsToKeep = set()\n\t\tdf = df.reset_index()\n\t\tfor column in searchColumns:\n\t\t\tfor rowIndex,value in df[column].iteritems():\n\t\t\t\tif rowIndex in rowsToKeep or not value: continue\n\t\t\t\tif not caseSensitive: value = value.lower()\n\t\t\t\tfor queryString in queryStrings:\n\t\t\t\t\tif matchSubstring and queryString in value or (not matchSubstring and queryString==value):\n\t\t\t\t\t\trowsToKeep.add(rowIndex)\n\t\t\t\t\t\tbreak\n\n\t\tgs._dataframe = df.loc[list(rowsToKeep),:].set_index('EnsemblId')\n\t\treturn gs","def filter_df(df):\n filtered_df = df[df['rtt_author_ids'].notnull()]\n filtered_df = filtered_df[filtered_df['user_country'] == 'FR']\n filtered_df = filtered_df[filtered_df['retweet_count'] > 1]\n filtered_df = filtered_df[filtered_df['favourites_count'] > 1000]\n return filtered_df","def filter_representative_sites_patient(\n df: pd.DataFrame, representative_sites: List[str]) -> pd.DataFrame:\n\n return df.loc[~(df['site'].isin(representative_sites))]","def filter(self):\n self.data = self.data.loc[~self.data.isnull().any(1),:]","def removeNonQuant(df, cols):\r\n df = df[~(df[cols].isnull().all(1))]\r\n return df","def clean_dataframe(self, df_in , what = ''): \n \n if what == 'era5fb': # cleaning the era5 feedback only \n df = df_in[np.isfinite(df_in['obsvalue@body'])]\n try: \n df = df.loc[ df['vertco_type@body'] != 2 ] \n except:\n pass\n df = df.reindex()\n df = df[np.isfinite(df['vertco_reference_1@body'])]\n #print('check lengths: ' , len(df_in) , len(df) )\n new_ind = np.array ( range(len(df))) \n df['index'] =new_ind\n df = df.set_index('index')\n \n else: \n ### check if can be optimized ???\n df = df_in.loc[ df_in['z_coordinate_type'] != 2 ] # case where the levels are given in terms of geopotential only (pressure not available)\n \n df = df.loc[ (df['observation_value'] != -99999.0) \n & (df['observation_value'] != -999.0) \n & (df['observation_value'] != -9999) \n & (df['observation_value'] != -9999.0) \n & (df['observation_value'] != -999.9) \n & (df['observation_value'] != -8888 )\n & (df['observation_value'] != -8888.0 )\n \n #& (df['z_coordinate_type'] != 2) \n & (df['z_coordinate'] != -99999.0) \n & (df['z_coordinate'] != -9999.0 )\n & (df['z_coordinate'] != 999 )\n & (df['z_coordinate'] != 999.0 )\n \n \n ] #cleaning the values \n #clean = clean.loc[ (clean['z_coordinate_type'] != 2)] #cleaning the values\n #clean = clean.loc[ (clean['z_coordinate'] != -99999.0 )] #cleaning the values\n \n df = df[np.isfinite(df['observation_value'])] # excluding nan values \n df = df[np.isfinite(df['z_coordinate'])]\n \n return df","def show_nan(df):\n nan_df = df[(~df['tweet_user_location'].str.lower().isin(\n [x.lower() for x in LOCATION_DISCARD])) & df['geonameid'].isnull()]\n print(f'Number of NaNs: {len(nan_df.index)}')\n return nan_df","def filter_triples(self, *triples: Optional[AnyTriples]) -> pandas.DataFrame:\n df = self.df\n for mapped_triples in triples:\n if mapped_triples is None:\n continue\n df = df[\n self._contains(\n df=df, mapped_triples=get_mapped_triples(mapped_triples, factory=self.factory), invert=True\n )\n ]\n return self.exchange_df(df=df)","def remove_not_available(df):\n drop_indices = df.index[df['genre'] == 'Not Available'].tolist()\n df = df.drop(drop_indices)\n return df","def clean_data(df, new_name=None):\n\n if new_name:\n original_name = df[\"from\"].unique().tolist()\n df.replace(original_name, new_name, inplace=True)\n df.dropna(subset=['text'], inplace=True)\n df.set_index('time', inplace=True, drop=False)\n return df","def _remove_lost_answers(self, df):\n tokenized_contexts = self.tokenizer.tokenize(\n df[\"context\"].tolist(), \"context\", special=False\n )\n lost_truncated, lost_dirty = self._lost_answers_indexes(df, tokenized_contexts)\n to_remove = lost_truncated + lost_dirty\n clean_df = df.drop(to_remove)\n assert len(clean_df) == len(df) - len(to_remove), (\n f\"Before {len(df)}, \" f\"after {len(clean_df)}, \" f\"removed {len(to_remove)}\"\n )\n return clean_df","def filter(self, filter_strings):\n if filter_strings is None:\n filter_strings = []\n\n result = RowSet()\n for row in self.rows:\n match = True\n for s in filter_strings:\n if not row.filter(s):\n match = False\n break\n if match:\n result.append(row)\n return result","def select_features(dfp):\n df = dfp[['5', '7', '12']].copy() \n df.columns=['type', 'duration','location']\n for col in df.columns:\n strings = df[col].unique()\n if col != \"location\":\n mapper = dict( zip(strings, range(len(strings))) )\n df[col].replace(mapper, inplace=True)\n else:\n df[col] = df[col].str.contains(\"LONDON\").astype(int)\n return df","def _screen(self, include=True, **kwargs):\n df = self.copy()\n for k, v in list(kwargs.items()):\n v = [v] if type(v) != list else v\n if include:\n df = df[df[k].str.contains('|'.join(v), flags=re.IGNORECASE).fillna(False)]\n else:\n df = df[df[k].str.contains('|'.join(v), flags=re.IGNORECASE).fillna(False) == False]\n return df","def filter_by(df, constraints):\n indexer = [constraints[name] if name in constraints else slice(None)\n for name in df.index.names]\n return df.loc[tuple(indexer)] if len(df.shape) == 1 else df.loc[tuple(indexer),]","def subset_pass_constraints(df):\n # All the constraints strings to test against. Must follow regex.\n # Keys: user-firendly constraint name, used for pass/fail bool column\n # Values: strings to test against\n accept_constraints = {\n \"pass_del_a_mu\": r\"Muon magn\\. mom\\. more than 2 sigma away\",\n \"pass_relic\": r\"Relic density too small \\(Planck\\)\",\n \"pass_bctaunu\": r\"b \\-> c tau nu more than 2 sigma away \\(as SM\\)\",\n \"pass_chi2zz\": r\"chi2\\(H\\->ZZ\\) > 6\\.18\",\n \"pass_chi2bb\": r\"chi2\\(H\\->bb\\) > 6\\.18\",\n \"pass_chi2gg\": r\"chi2\\(H\\->gg\\) > 6\\.18\",\n \"pass_cms4mu\": r\"Excluded H_125\\->AA\\->4mu \\(CMS\\)\"\n }\n for k, v in accept_constraints.iteritems():\n df[k] = ~df.constraints.str.contains(v)\n\n # We want a bitmask, so for each entry we simply want a True or False\n # First make a copy of the constraints Series\n con_series = df.constraints.copy(deep=True)\n # Now for each entry we remove the constraints we don't mind failing\n for c in accept_constraints.values():\n con_series = con_series.str.replace(c, \"\")\n # con_series = con_series.str.replace(r\"^\\|+$\", \"\") # Any leftover separators\n con_series = con_series.apply(lambda x: x.strip('|'))\n con_series = con_series.str.replace(r\"\\|\\|+\", r\"|\") # Any multiple separators\n # Now figure out which ones are empty\n mask = con_series.str.match(\"^$\")\n # Return those entries, allowing for a +ve muon mag moment contribution\n return df[mask & (df.Del_a_mu > 0)]","def filter_existing_samples(df, sample_id_colname, remote_samples):\n remote_sample_ids = remote_samples['entity:sample_id'].tolist()\n df_clean = df[~df[sample_id_colname].isin(remote_sample_ids)]\n return df_clean","def get_all_contests(data_frame) -> list:\n return [contest for contest in data_frame.columns if contest != 'Ballot Style']","def _remove_all_matches(values, needle):\n values[:] = (i for i in values if i != needle)","def delete_entries(df, column, values):\n for val in values:\n dropindex = df[df[column] == val].index\n df.drop(index = dropindex, inplace = True)","def cleaning(df, file=\"proteinGroups\"):\r\n columns = df.columns\r\n if file == \"proteinGroups\":\r\n if (\"Potential contaminant\" not in columns) or\\\r\n (\"Reverse\" not in columns) or\\\r\n (\"Only identified by site\" not in columns):\r\n print(\"Is this data already cleaned?\\nMandatory columns for cleaning not present in data!\")\r\n print(\"Returning provided dataframe!\")\r\n return df\r\n df = df[(df['Potential contaminant'].isnull()) &\r\n (df['Reverse'].isnull()) &\r\n (df['Only identified by site'].isnull())]\r\n df.drop(['Potential contaminant',\"Reverse\", 'Only identified by site'], axis=1, inplace=True)\r\n elif (file == \"Phospho (STY)\") or (file == \"evidence\") or (file == \"modificationSpecificPeptides\"):\r\n if (\"Potential contaminant\" not in columns) or\\\r\n (\"Reverse\" not in columns):\r\n print(\"Is this data already cleaned?\\nMandatory columns for cleaning not present in data!\")\r\n print(\"Returning provided dataframe!\")\r\n return df\r\n df = df[(df['Potential contaminant'].isnull()) &\r\n (df['Reverse'].isnull())]\r\n df.drop(['Potential contaminant',\"Reverse\"], axis=1, inplace=True)\r\n return df","def df_cleaner(df):\n return df.dropna()","def _filter(self, col: str, val: Any) -> pd.DataFrame:\n return self._df[self._df[col] == val]","def fixed(df: pd.DataFrame, fixers: dict, not_equal=False) -> pd.DataFrame:\n selector = None\n for k, v in fixers.items():\n if selector is None:\n if not_equal:\n selector = (df[k] != v)\n else:\n selector = (df[k] == v)\n else:\n if not_equal:\n selector = np.logical_and(selector, df[k] != v)\n else:\n selector = np.logical_and(selector, df[k] == v)\n if selector is None:\n return df.copy()\n else:\n return df[selector].reset_index(drop=True).copy()","def cleaned(df):\n\n cdf = df.copy()\n lcdf = len(cdf)\n\n danglings = []\n ld = len(danglings)\n\n print('cleaning data frame')\n iteration_times = 1\n while True:\n for index, row in cdf.iterrows():\n if index in danglings:\n cdf = cdf.drop(index)\n elif not (cdf['from'] == row['to']).any():\n danglings.append(index)\n cdf = cdf.drop(index)\n\n if not index % 77:\n print(f'{del_line}{index / lcdf * 100:2.1f}% #{iteration_times}', end='')\n iteration_times += 1\n\n # iterate until `danglings` does not change\n if len(danglings) == ld:\n break\n else:\n ld = len(danglings)\n\n print(f'{del_line}data cleaned with {iteration_times} iterations')\n\n return cdf, np.array(danglings)","def _get_target_only_columns(self, df: DataFrame) -> DataFrame:\n target_table_columns = self.target_table.get_columns()\n \n # if mutation of incoming df is desired, make a deepcopy here\n filtered_df = df\n for column in filtered_df.columns:\n if column not in target_table_columns:\n print(f'dropping unused column \"{column}\"')\n filtered_df = filtered_df.drop(column)\n \n return filtered_df","def query(df: pd.DataFrame) -> pd.DataFrame:\n pydref = pdref.Pydref()\n logger = get_logger(threading.current_thread().name)\n logger.info(\"start\")\n part_idref = {\"person_id\": [], \"name_corrected\": [], \"idref\": []}\n for _, r in df.iterrows():\n try:\n result = pydref.identify(r[\"name_corrected\"])\n if result.get(\"status\") == \"found\":\n part_idref[\"person_id\"].append(r[\"person_id\"])\n part_idref[\"name_corrected\"].append(r[\"name_corrected\"])\n part_idref[\"idref\"].append(result.get(\"idref\"))\n except:\n pass\n\n df = pd.DataFrame(data=part_idref)\n df[\"person_id\"] = df[\"person_id\"].astype(pd.Int64Dtype())\n logger.info(\"end\")\n\n return df","def _filter_data(self, pattern):\n removed = []\n filtered = []\n for param in self.data:\n if not param[0].startswith(pattern):\n filtered.append(param)\n else:\n removed.append(param)\n self.data = filtered\n return removed","def drop_transactions(df, station, access_point = None):\n\n if access_point is not None:\n station_name = df.nombreestacion.contains(station)\n entrance = df.nombreaccesoestacion.contains(access_point)\n filters = station_name & entrance\n else:\n filters = df.nombreestacion.contains(station)\n return df.filter(~filters)","def filter_data(self):\n self.df = self.df[HeatStrokeDataFiller.important_features]","def clean_data(input_df, output_df):\n all_rows = pd.concat([input_df, output_df], axis=1)\n all_rows.dropna(how='all', inplace=True)\n input_df = all_rows.iloc[:, 0:input_df.shape[1]]\n output_df = all_rows.iloc[:, input_df.shape[1]:all_rows.shape[1]]\n return input_df, output_df","def filter_by_isin(df: pd.DataFrame, column: str, values: Iterable) -> pd.DataFrame:\n # First, create a \"map\" series from all possible values in the column => whether they should pass the filter\n all_ids = df[column].unique()\n is_id_relevant = pd.Series(np.zeros(len(all_ids)), index=all_ids).astype('bool') # Default false\n is_id_relevant.loc[values] = True\n\n # Create a boolean mask for column, based on the mapping above. Grab the raw array.\n mask = is_id_relevant[df[column]].values\n # Apply mask\n return df[mask]","def remove_players_wo_positions(df):\n df = df[pd.notnull(df['FantPos'])]\n return df","def filter_df(df, month, day):\n\n #filter by month\n df = df.loc[df['month'] == month]\n\n #filter by day\n df = df.loc[df['day_of_week'] == day]\n\n return df","def drop_uniform_slice_from_dataframe(df, value, axis=0):\n\n if axis == 0:\n dropped = (df == value).all(axis=0)\n if any(dropped):\n print('Removed {} column index(ices) whose values are all {}.'.\n format(dropped.sum(), value))\n return df.ix[:, ~dropped]\n\n elif axis == 1:\n dropped = (df == value).all(axis=1)\n if any(dropped):\n print('Removed {} row index(ices) whose values are all {}.'.format(\n dropped.sum(), value))\n return df.ix[~dropped, :]","def column_eliminate(values):\n solved_values = [box for box in values.keys() if len(values[box]) == 1]\n for box in solved_values:\n \n location = values[box][0] #a solved location in a column\n if location in location_dict.keys():\n \n #ensure that multiple groups can be in multiple locations using period_loc_frequency\n loc_freq = 0\n loc_freq -= 1 #subtract one for the current location usage\n loc_freq += period_loc_frequency[location]\n \n for other_col in column_dict[box]:\n if other_col in solved_values:\n if values[other_col] == location:\n loc_freq -= 1\n \n #make sure that too many locations haven't been used up yet\n if loc_freq < 0:\n print(\"error: too many groups in location\", location)\n \n #if the location is \"used up\", remove it as an option from the rest of the groups\n if loc_freq == 0:\n for other_col in column_dict[box]:\n try:\n values[other_col].remove(location) #remove the location from the other column units\n except:\n pass\n \n return values","def filter_values(df, value=0, axis=0):\n \n if axis:\n return df.loc[:, (df != value).any(axis=1-axis)]\n else:\n return df.loc[(df != value).any(axis=1-axis)]","def filterfeatures(df):\n\tfilter_arr = []\n\tfor f in df.columns:\n\t\tif not '.l' in f and not '.r' in f and not '.std' in f and f != 'weight' and f != 'class':\n\t\t\t# filter_arr.append(f.rstrip('.mean'))\n\t\t\tfilter_arr.append(f)\n\treturn filter_arr","def exclude(requestContext, seriesList, pattern):\n regex = re.compile(pattern)\n return [s for s in seriesList if not regex.search(s.name)]","def filter_by_names(df, names_list):\n return df.ix[names_list]","def clean_data(df):\n \n any_location_id_missing = (df.PULocationID > 263) | (df.DOLocationID > 263)\n df = df.drop(df.index[any_location_id_missing])\n \n df = df[df.tpep_dropoff_datetime > df.tpep_pickup_datetime]\n\n df.PULocationID.replace([104, 105], 103)\n \n return df","def _truncate_games_df(df, season, season_type):\n return df[(df['season'] != season) | (df['type'] != season_type)]","def filter_dataframe_by_composition(df, composition, formula_column=\"Composition\"):\n # Get elements in formula, composition, then filter\n chemsys = set(Composition(composition).keys())\n all_comps = df[formula_column].apply(Composition)\n indices_to_include = [ind for ind, comp in all_comps.items()\n if comp.keys() <= chemsys]\n return df.loc[indices_to_include]","def df_cleaner(df):\n df = df.dropna()\n return df","def get_valid_passwords(df, validation_method):\n # list of indices that should be dropped\n drop = []\n\n # find all invalid passwords\n for i in range(len(df.index)):\n if not validation_method(df.iloc[i]):\n drop.append(i)\n\n # drop invalid passwords and return dataframe\n return df.drop(drop).reset_index(drop=True)","def get_compound_df(df):\n columns = {'Name':'analyte', 'Amount': 'measurement'}\n df['Compound'].rename(columns=columns, inplace=True)\n df_compound = df['Compound'].copy()\n df_compound.loc[(df_compound.analyte.isnull()) & (df_compound.measurement > 0), 'analyte'] = 'wildcard'\n df_compound.dropna(subset = ['analyte'], inplace=True)\n return df_compound","def remove_blank_rows(df):\n clean_df = df.filter(df.columns[1:], axis=1).dropna(how='all', axis=0)\n idx_to_keep = clean_df.index\n clean_df = df.filter(idx_to_keep, axis=0)\n return clean_df","def filter_data(df, needed_columns, not_null_columns=[]):\n\n if all(x in needed_columns for x in not_null_columns):\n\n df = get_needed_columns(df, needed_columns)\n #Use the pandas method bc the other method was erroring on boolean index.\n #IM - 9/23/22\n df = df.dropna(subset=not_null_columns)#remove_rows_with_null_values(df, not_null_columns)\n\n return df\n else:\n print(\"Developer error, not null columns should be a subset of needed columns\")\n return df","def get_world_df(df: pd.DataFrame) -> pd.DataFrame:\n\n return df[\n df[Columns.LOCATION_NAME].isin(\n [Locations.WORLD, Locations.WORLD_MINUS_CHINA, Locations.CHINA]\n )\n ]","def standart_filter(left_df, right_df):\n return left_df.join(right_df, left_df.tconst == right_df.tconst) \\\n .drop(right_df.tconst) \\\n .filter((left_df.titleType == 'movie')\n & (right_df.numVotes >= 100000))","def search_premade(phrase = '*',\n language = 'en',\n url = 'http://data.ssb.no/api/v0/dataset'):\n url = '{url}?lang={language}'.format(\n url = url,\n language = language)\n \n df = pd.read_html(url)\n df = df[0]\n df.index = df['ID']\n df = df.iloc[:,[0,1]]\n df = df.sort_index()\n phrase = phrase.lower()\n \n if phrase != '*':\n df = df[(df.iloc[:,0].str.lower().str.contains(phrase)) | \n (df.iloc[:,1].str.lower().str.contains(phrase)) ]\n return df","def _query_df(self, opt: dict):\n query = []\n for k in self.unique_keys:\n val = opt[k]\n if isinstance(val, str):\n query.append(f\"{k}=='{val}'\")\n else:\n query.append(f\"{k}=={val}\")\n return self.data.query(\" and \".join(query).strip())","def _description_filter(self, df):\n df = df[df['Description'].str.contains(\"and\")]\n df['Description'] = df['Description'].map(lambda x: x[:MAX_DESC_LENGTH])\n return df","def filter_rows(self, **kwargs):\n filtered = self._data.copy()\n for colname, values in kwargs.items():\n values = [values] if type(values) == str else values\n filtered = filtered[filtered[colname].isin(values)]\n return self._copy(filtered)","def normData( df, inSirenName=\"./siren_in.csv\", gtName=\"./Greentech_All_VF4_green.xlsx\", gt_sheet_name=\"FICHIER COMPLET\" ) :\n sirens_g = pd.read_excel( gtName, gt_sheet_name)[\"SIREN\"].tolist()\n print( \"Number of known GreenTechs:\", len(sirens_g))\n\n sirens = pd.read_csv( inSirenName )[\"siren\"].tolist()\n print(\"Number of whole eligible companies:\", len(sirens))\n\n return df[ ( df[\"SIREN\"].isin( sirens ) ) & ( ~df[\"SIREN\"].isin( sirens_g ) ) ]","def clean_up_raw(df_raw):\n # exclude_subset = ['well', 'tile', 'cell', 'intensity', 'blob'] # causes issues with later joins, maybe a pandas bug\n import lasagna.utils\n df_raw[CYCLE] = df_raw[CYCLE].astype(int)\n df_raw = df_raw.sort_values([WELL, TILE, CELL, BLOB, CYCLE, CHANNEL])\n return df_raw","def filter_rows(self, **kwds):\n if kwds:\n normalize = lambda v: (v,) if isinstance(v, str) else v\n kwds = dict((k, normalize(v)) for k, v in kwds.items())\n matches_kwds = lambda row: all(row[k] in v for k, v in kwds.items())\n return filter(matches_kwds, self.__iter__())\n return self.__iter__()","def filterRows(function, rows):\n return [y for y in rows if function(y)]","def remove_guides(df, rm_guides):\n df = df[~(df.anchor_guide.isin(rm_guides))]\n return df","def result_df(self, regex=None) -> pd.DataFrame:\n if regex:\n # get one random item from dict, and get keys from this random (dict) item\n # FIXME: how to do this better? - this is not efficient...\n keys = self.result[next(iter(self.result))].keys()\n\n if type(regex) == str:\n comp_regexe = re.compile(regex)\n columns = list(filter(comp_regexe.search, keys))\n else:\n columns = list(filter(regex.search, keys))\n\n df = pd.DataFrame.from_dict(self.result, orient='index')\n return df[columns]\n else:\n return pd.DataFrame.from_dict(self.result, orient='index')","def subsetmask(df, mask_df = get_contest_mask()):\n return pd.merge(df, mask_df, on=['lat', 'lon'], how='inner')","def _filter_valid_id(df, col):\n df = df[(df[col].str.isnumeric().replace({np.nan: False})) &\n (df[col] != '0') &\n (df[col] != 0)]\n return df","def clean_ferc714_hourly_demand_matrix(df: pd.DataFrame) -> pd.DataFrame:\n ts = pudl.analysis.timeseries_cleaning.Timeseries(df)\n ts.flag_ruggles()\n return ts.to_dataframe(copy=False)","def searchable_data(df, columns):\n df['searchable_data'] = df[columns].apply(lambda x: ' '.join(x), axis=1)\n df = df.drop(columns, axis=1)\n df['searchable_data'] = df['searchable_data'].map(clean_data)\n return df","def filter_hets(gens_df):\n\tgenotype_cols = list(set(gens_df.columns).difference(set(['chrom', 'pos', 'ref', 'alt'])))\n\tgens_df['het'] = gens_df.apply(lambda row: any(het(row[col]) for col in genotype_cols), axis=1)\n\tout = gens_df.query('het')[['chrom', 'pos', 'ref', 'alt']+genotype_cols]\n\treturn out","def get_rxn_subset(input_hdf5, rxn_df_key):\n rxn_df = pd.read_hdf(input_hdf5, rxn_df_key)\n # Subset filtering criteria; can be updated as required\n # For instance, when the Pubchem ids of all the chemicals with score >= 50 have been fetched,\n # Status75 below can be chnaged to Status 50. Currently, all the chemicals with scores >= 90\n # have been fetched\n rxn_df = rxn_df.query(\"Products_Available == True & Status_75 == True\")\n\n # Now we will get rid of all the rows that have 'NaN' in their CID list or if they have any adduct\n to_be_dropped = []\n for idx, row in rxn_df.iterrows():\n cid_list = row['ReactantCID'] + row['ProductCID']\n for ele in cid_list:\n if math.isnan(ele) or re.search(\"adduct\", row['Reactants']+row['Products'], re.IGNORECASE):\n to_be_dropped.append(idx)\n break\n\n rxn_df = rxn_df.drop(to_be_dropped)\n return rxn_df","def subsetmask(df, mask_df):\r\n return pd.merge(df, mask_df, on=['lat', 'lon'], how='inner')"],"string":"[\n \"def prune(df, regex_list):\\n for regex_pattern in regex_list:\\n df = df[~df.case_action.str.contains(regex_pattern)]\\n return df\",\n \"def clean(df):\",\n \"def filter_same_helix(df):\\n helixpattern = re.compile(r\\\"\\\"\\\"^(..)\\\\w+\\\\s+\\\\1\\\"\\\"\\\")#For detecting same-helix contacts, the ones like 1.22x22 1.54x54\\n helixfilter = df['Position'].str.contains(helixpattern)\\n df = df[~helixfilter]\\n return(df)\",\n \"def filter_processes(ps_df: pd.DataFrame, user_query: str) -> pd.DataFrame:\\n user_query = user_query.strip('\\\\'')\\n result_df = ps_df.query(user_query)\\n return result_df\",\n \"def pattern_search(pattern, dataset, column):\\n # Filter\\n dataset = dataset[dataset[column].str.contains(pattern, regex=True)]\\n # Reset index\\n dataset = dataset.reset_index(drop=True)\\n # Return\\n return dataset\",\n \"def minus_df(df):\\n return df[df[\\\"content\\\"].str.contains(\\\"(^|[^0-9])\\\\-[0-9]+\\\")]\",\n \"def filter(df, predicate):\\n if not df:\\n return []\\n\\n return [row for row in df if predicate(row)]\",\n \"def _filter_df(adjmat, df, verbose=3):\\n remcols = df.columns[~np.isin(df.columns.values, adjmat.columns.values)].values\\n if len(remcols)>0:\\n if verbose>=3: print('[bnlearn] >Removing columns from dataframe to make consistent with DAG [%s]' %(remcols))\\n df.drop(labels=remcols, axis=1, inplace=True)\\n return df\",\n \"def _filter_df(adjmat, df, verbose=3):\\n remcols = df.columns[~np.isin(df.columns.values, adjmat.columns.values)].values\\n if len(remcols)>0:\\n if verbose>=3: print('[bnlearn] >Removing columns from dataframe to make consistent with DAG [%s]' %(remcols))\\n df.drop(labels=remcols, axis=1, inplace=True)\\n return df\",\n \"def _clean_dataset(df: pd.DataFrame) -> pd.DataFrame:\\n df = df.loc[:, ~df.columns.str.contains(\\\"^Unnamed\\\")]\\n df = df.dropna()\\n return df\",\n \"def trimDf(df):\\n cols = set(df.columns)\\n\\n cols.remove('exclamationCount') # bug in our feature extraction code\\n cols.remove('price') # considered only free apps\\n cols.remove('appName') # removing appNames\\n\\n # return df[list(cols)]\\n\\n\\n\\n return df[list(('revSent', 'appLabel'))]\",\n \"def get_subtable(df, col, val) -> pd.DataFrame:\\r\\n return df[df[col] == val].drop(columns=col)\",\n \"def remove_other_elements(data):\\n charset = ['F','l','B','r','I','i','M','g','L','b','a','e','K','V','d','R','Z','G','A','Y','u']\\n x = []\\n for i in range(data.shape[0]):\\n for j in range(len(data.iloc[i,1])):\\n if data.iloc[i,1][j] in charset:\\n x.append(i)\\n break\\n df = data[(True^data['Index'].isin(x))]\\n df.reset_index(drop=True, inplace=True)\\n return df\",\n \"def clean(self):\\n self.df = _data.prune(self.df, [REGEX_PATTERN_GCI, REGEX_PATTERN_DB_ID])\\n self.df, _ = _data.remove_totally_failed_tests(self.df)\\n self.is_cleaned = True\",\n \"def filter_blacklist(df, path):\\n f = open(path)\\n patterns = [e.strip() for e in f.readlines()]\\n f.close()\\n\\n def run_filter(x):\\n for pat in patterns:\\n if fnmatch.fnmatch(x, pat):\\n return True\\n return False\\n\\n index = df[df[PROD_NM].apply(run_filter)].index\\n df.drop(columns=[PROD_NM], index=index, inplace=True)\",\n \"def drop_irrelevant_practices(df):\\n\\n is_relevant = df.groupby(\\\"practice\\\").value.any()\\n return df[df.practice.isin(is_relevant[is_relevant == True].index)]\",\n \"def _remove_non_informative_rows(self, df, threshold):\\n df_tmp = pd.DataFrame()\\n n_features = len(df.columns)\\n # calculating ratio of rows that have more than \\\"ratio\\\" missing values\\n df_tmp['ratio'] = df.apply(lambda row: row.isnull().sum()/n_features, axis='columns')\\n\\n # kick too noisy rows\\n return df[df_tmp['ratio'] <= threshold]\",\n \"def cleanDf(df, badaa=None):\\n return df.loc[[isvalidpeptide(s, badaa) for s in df.seq]]\",\n \"def remove_rows_with_non_english_movies(df):\\n df = df[df['original_language'] == 'en']\\n return df\",\n \"def clean_rows_cat_values(df: pd.DataFrame, col: str, values: list) -> pd.DataFrame:\\n\\n # create mask to filter df with rows that have\\n # the indicated values in the indicated column\\n index = df.columns.get_loc(col)\\n mask = [df.iloc[row, index] not in values for row in range(len(df))]\\n\\n # print original dataframe shape\\n print(f\\\"Shape of the original dataframe: \\\\n{df.shape}\\\\n\\\")\\n\\n # filter df\\n df = df.iloc[mask]\\n df.reset_index(drop=True, inplace=True)\\n print(\\n f\\\"Shape after removing rows with values equal to\\\\n{values}\\\\nin column '{col}'':\\\"\\n )\\n print(df.shape, \\\"\\\\n\\\")\\n\\n return df\",\n \"def select_feats(df):\\n cols = list(df)\\n for col in cols:\\n if col not in config[\\\"feats\\\"] and col != \\\"label\\\":\\n df = df.drop(columns=col)\\n return df\",\n \"def clean_unknown(df, db, index_col='id'):\\n ind = []\\n for i, gene_id in enumerate(df[index_col]):\\n try:\\n db[gene_id]\\n ind.append(i)\\n except gffutils.FeatureNotFoundError:\\n continue\\n return df.ix[ind, :]\",\n \"def filter_cols(df):\\n comm_keys = list( set(df.keys()) & set(KEYS_FOR_ML) )\\n filt_col_df = df.copy()[comm_keys]\\n\\n return filt_col_df\",\n \"def remove_rows_without_feature(df, feature):\\n return df[np.isfinite(df[feature])]\",\n \"def deletingNaNs(df):\\n # start_ time.time()\\n df_old = df.copy()\\n df.dropna(axis=1, how='any', inplace=True)\\n for key in df_old:\\n if str(key) not in df:\\n print('Deleted ', key)\\n # end_time time.time()\\n #print('Time to run deletingNaNs: ', end_time - start_time)\\n return df\",\n \"def extract_relevant_rows(df, column_name, column_value, not_equal=False):\\n\\n if not_equal:\\n return df.loc[df[column_name] != column_value]\\n\\n return df.loc[df[column_name] == column_value]\",\n \"def filter_input(input_df, target_df):\\n # input_df = input_df.reindex(target_df.index, copy=False)\\n data_df = pd.concat((input_df, target_df), join=\\\"inner\\\", copy=False, axis=1)\\n return data_df\",\n \"def delete_matches(self, pattern):\\n with self.connect() as c:\\n cur = c.cursor()\\n cur.execute(self.create_query(\\\"DELETE\\\", pattern))\",\n \"def unmatching_driver_id(df):\\n\\ttemp = df[df['driver_id_bkg'].notnull()]\\n\\torder_ids = temp[temp['driver_id_bkg'] != temp['driver_id_pnt']]['order_id'].values\\n\\treturn df[~df['order_id'].isin(order_ids)]\",\n \"def drop_transafers(df):\\n return df.filter(~(df.valor == 0))\",\n \"def data_cleaning(df):\\n df = df.dropna(how='all')\\n \\n return df\",\n \"def delete_problematic_entries(\\n df: pd.DataFrame,\\n members_no_address_at_all: Set,\\n members_no_zipCity: Set,\\n members_with_invalid_matrices: Set,\\n) -> pd.DataFrame:\\n members_to_delete = members_no_address_at_all.union(members_no_zipCity).union(\\n members_with_invalid_matrices\\n )\\n\\n df = df.loc[~df[\\\"memberid\\\"].isin(members_to_delete)]\\n return df\",\n \"def filter_by_match(df: pd.DataFrame, d: dict) -> np.ndarray:\\n incl = np.ones([len(df)], dtype=bool)\\n for k, v in d.items():\\n incl = incl & (df[k] == v)\\n return incl\",\n \"def subset(self, *args, **kwargs):\\n\\t\\tgs = copy.copy(self)\\n\\t\\tqueryStrings = kwargs['queryStrings'] if 'queryStrings' in kwargs else args[0] if args else []\\n\\t\\tif isinstance(queryStrings, str) or isinstance(queryStrings, bytes):\\t# assume queryString was specified as a string\\n\\t\\t\\tqueryStrings = [queryStrings]\\n\\t\\n\\t\\tif len(queryStrings)==0:\\n\\t\\t\\treturn gs\\n\\t\\t\\t\\n\\t\\tdf = gs._dataframe\\n\\t\\t\\n\\t\\tif 'species' in kwargs and kwargs['species'] in ['MusMusculus','HomoSapiens']:\\n\\t\\t\\tdf = df[df['Species']==kwargs['species']]\\n\\t\\t\\t\\n\\t\\tcaseSensitive = kwargs.get('caseSensitive', False)\\n\\t\\tif not caseSensitive: queryStrings = [item.lower() for item in queryStrings]\\n\\t\\t\\n\\t\\tmatchSubstring = kwargs.get('matchSubstring', True)\\n\\t\\t\\n\\t\\t# determine which columns to search\\n\\t\\tsearchColumns = kwargs.get('searchColumns')\\n\\t\\tallColumns = ['EnsemblId','EntrezId','GeneSymbol','Synonyms','Description']\\n\\t\\tif searchColumns:\\n\\t\\t\\tsearchColumns = ['EnsemblId' if item=='GeneId' or item=='geneId' else item for item in searchColumns]\\n\\t\\tif searchColumns and len(set(allColumns).intersection(set(searchColumns)))>0:\\n\\t\\t\\tsearchColumns = list(set(allColumns).intersection(set(searchColumns)))\\n\\t\\telse:\\n\\t\\t\\tsearchColumns = allColumns\\n\\t\\t\\n\\t\\trowsToKeep = set()\\n\\t\\tdf = df.reset_index()\\n\\t\\tfor column in searchColumns:\\n\\t\\t\\tfor rowIndex,value in df[column].iteritems():\\n\\t\\t\\t\\tif rowIndex in rowsToKeep or not value: continue\\n\\t\\t\\t\\tif not caseSensitive: value = value.lower()\\n\\t\\t\\t\\tfor queryString in queryStrings:\\n\\t\\t\\t\\t\\tif matchSubstring and queryString in value or (not matchSubstring and queryString==value):\\n\\t\\t\\t\\t\\t\\trowsToKeep.add(rowIndex)\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\tgs._dataframe = df.loc[list(rowsToKeep),:].set_index('EnsemblId')\\n\\t\\treturn gs\",\n \"def filter_df(df):\\n filtered_df = df[df['rtt_author_ids'].notnull()]\\n filtered_df = filtered_df[filtered_df['user_country'] == 'FR']\\n filtered_df = filtered_df[filtered_df['retweet_count'] > 1]\\n filtered_df = filtered_df[filtered_df['favourites_count'] > 1000]\\n return filtered_df\",\n \"def filter_representative_sites_patient(\\n df: pd.DataFrame, representative_sites: List[str]) -> pd.DataFrame:\\n\\n return df.loc[~(df['site'].isin(representative_sites))]\",\n \"def filter(self):\\n self.data = self.data.loc[~self.data.isnull().any(1),:]\",\n \"def removeNonQuant(df, cols):\\r\\n df = df[~(df[cols].isnull().all(1))]\\r\\n return df\",\n \"def clean_dataframe(self, df_in , what = ''): \\n \\n if what == 'era5fb': # cleaning the era5 feedback only \\n df = df_in[np.isfinite(df_in['obsvalue@body'])]\\n try: \\n df = df.loc[ df['vertco_type@body'] != 2 ] \\n except:\\n pass\\n df = df.reindex()\\n df = df[np.isfinite(df['vertco_reference_1@body'])]\\n #print('check lengths: ' , len(df_in) , len(df) )\\n new_ind = np.array ( range(len(df))) \\n df['index'] =new_ind\\n df = df.set_index('index')\\n \\n else: \\n ### check if can be optimized ???\\n df = df_in.loc[ df_in['z_coordinate_type'] != 2 ] # case where the levels are given in terms of geopotential only (pressure not available)\\n \\n df = df.loc[ (df['observation_value'] != -99999.0) \\n & (df['observation_value'] != -999.0) \\n & (df['observation_value'] != -9999) \\n & (df['observation_value'] != -9999.0) \\n & (df['observation_value'] != -999.9) \\n & (df['observation_value'] != -8888 )\\n & (df['observation_value'] != -8888.0 )\\n \\n #& (df['z_coordinate_type'] != 2) \\n & (df['z_coordinate'] != -99999.0) \\n & (df['z_coordinate'] != -9999.0 )\\n & (df['z_coordinate'] != 999 )\\n & (df['z_coordinate'] != 999.0 )\\n \\n \\n ] #cleaning the values \\n #clean = clean.loc[ (clean['z_coordinate_type'] != 2)] #cleaning the values\\n #clean = clean.loc[ (clean['z_coordinate'] != -99999.0 )] #cleaning the values\\n \\n df = df[np.isfinite(df['observation_value'])] # excluding nan values \\n df = df[np.isfinite(df['z_coordinate'])]\\n \\n return df\",\n \"def show_nan(df):\\n nan_df = df[(~df['tweet_user_location'].str.lower().isin(\\n [x.lower() for x in LOCATION_DISCARD])) & df['geonameid'].isnull()]\\n print(f'Number of NaNs: {len(nan_df.index)}')\\n return nan_df\",\n \"def filter_triples(self, *triples: Optional[AnyTriples]) -> pandas.DataFrame:\\n df = self.df\\n for mapped_triples in triples:\\n if mapped_triples is None:\\n continue\\n df = df[\\n self._contains(\\n df=df, mapped_triples=get_mapped_triples(mapped_triples, factory=self.factory), invert=True\\n )\\n ]\\n return self.exchange_df(df=df)\",\n \"def remove_not_available(df):\\n drop_indices = df.index[df['genre'] == 'Not Available'].tolist()\\n df = df.drop(drop_indices)\\n return df\",\n \"def clean_data(df, new_name=None):\\n\\n if new_name:\\n original_name = df[\\\"from\\\"].unique().tolist()\\n df.replace(original_name, new_name, inplace=True)\\n df.dropna(subset=['text'], inplace=True)\\n df.set_index('time', inplace=True, drop=False)\\n return df\",\n \"def _remove_lost_answers(self, df):\\n tokenized_contexts = self.tokenizer.tokenize(\\n df[\\\"context\\\"].tolist(), \\\"context\\\", special=False\\n )\\n lost_truncated, lost_dirty = self._lost_answers_indexes(df, tokenized_contexts)\\n to_remove = lost_truncated + lost_dirty\\n clean_df = df.drop(to_remove)\\n assert len(clean_df) == len(df) - len(to_remove), (\\n f\\\"Before {len(df)}, \\\" f\\\"after {len(clean_df)}, \\\" f\\\"removed {len(to_remove)}\\\"\\n )\\n return clean_df\",\n \"def filter(self, filter_strings):\\n if filter_strings is None:\\n filter_strings = []\\n\\n result = RowSet()\\n for row in self.rows:\\n match = True\\n for s in filter_strings:\\n if not row.filter(s):\\n match = False\\n break\\n if match:\\n result.append(row)\\n return result\",\n \"def select_features(dfp):\\n df = dfp[['5', '7', '12']].copy() \\n df.columns=['type', 'duration','location']\\n for col in df.columns:\\n strings = df[col].unique()\\n if col != \\\"location\\\":\\n mapper = dict( zip(strings, range(len(strings))) )\\n df[col].replace(mapper, inplace=True)\\n else:\\n df[col] = df[col].str.contains(\\\"LONDON\\\").astype(int)\\n return df\",\n \"def _screen(self, include=True, **kwargs):\\n df = self.copy()\\n for k, v in list(kwargs.items()):\\n v = [v] if type(v) != list else v\\n if include:\\n df = df[df[k].str.contains('|'.join(v), flags=re.IGNORECASE).fillna(False)]\\n else:\\n df = df[df[k].str.contains('|'.join(v), flags=re.IGNORECASE).fillna(False) == False]\\n return df\",\n \"def filter_by(df, constraints):\\n indexer = [constraints[name] if name in constraints else slice(None)\\n for name in df.index.names]\\n return df.loc[tuple(indexer)] if len(df.shape) == 1 else df.loc[tuple(indexer),]\",\n \"def subset_pass_constraints(df):\\n # All the constraints strings to test against. Must follow regex.\\n # Keys: user-firendly constraint name, used for pass/fail bool column\\n # Values: strings to test against\\n accept_constraints = {\\n \\\"pass_del_a_mu\\\": r\\\"Muon magn\\\\. mom\\\\. more than 2 sigma away\\\",\\n \\\"pass_relic\\\": r\\\"Relic density too small \\\\(Planck\\\\)\\\",\\n \\\"pass_bctaunu\\\": r\\\"b \\\\-> c tau nu more than 2 sigma away \\\\(as SM\\\\)\\\",\\n \\\"pass_chi2zz\\\": r\\\"chi2\\\\(H\\\\->ZZ\\\\) > 6\\\\.18\\\",\\n \\\"pass_chi2bb\\\": r\\\"chi2\\\\(H\\\\->bb\\\\) > 6\\\\.18\\\",\\n \\\"pass_chi2gg\\\": r\\\"chi2\\\\(H\\\\->gg\\\\) > 6\\\\.18\\\",\\n \\\"pass_cms4mu\\\": r\\\"Excluded H_125\\\\->AA\\\\->4mu \\\\(CMS\\\\)\\\"\\n }\\n for k, v in accept_constraints.iteritems():\\n df[k] = ~df.constraints.str.contains(v)\\n\\n # We want a bitmask, so for each entry we simply want a True or False\\n # First make a copy of the constraints Series\\n con_series = df.constraints.copy(deep=True)\\n # Now for each entry we remove the constraints we don't mind failing\\n for c in accept_constraints.values():\\n con_series = con_series.str.replace(c, \\\"\\\")\\n # con_series = con_series.str.replace(r\\\"^\\\\|+$\\\", \\\"\\\") # Any leftover separators\\n con_series = con_series.apply(lambda x: x.strip('|'))\\n con_series = con_series.str.replace(r\\\"\\\\|\\\\|+\\\", r\\\"|\\\") # Any multiple separators\\n # Now figure out which ones are empty\\n mask = con_series.str.match(\\\"^$\\\")\\n # Return those entries, allowing for a +ve muon mag moment contribution\\n return df[mask & (df.Del_a_mu > 0)]\",\n \"def filter_existing_samples(df, sample_id_colname, remote_samples):\\n remote_sample_ids = remote_samples['entity:sample_id'].tolist()\\n df_clean = df[~df[sample_id_colname].isin(remote_sample_ids)]\\n return df_clean\",\n \"def get_all_contests(data_frame) -> list:\\n return [contest for contest in data_frame.columns if contest != 'Ballot Style']\",\n \"def _remove_all_matches(values, needle):\\n values[:] = (i for i in values if i != needle)\",\n \"def delete_entries(df, column, values):\\n for val in values:\\n dropindex = df[df[column] == val].index\\n df.drop(index = dropindex, inplace = True)\",\n \"def cleaning(df, file=\\\"proteinGroups\\\"):\\r\\n columns = df.columns\\r\\n if file == \\\"proteinGroups\\\":\\r\\n if (\\\"Potential contaminant\\\" not in columns) or\\\\\\r\\n (\\\"Reverse\\\" not in columns) or\\\\\\r\\n (\\\"Only identified by site\\\" not in columns):\\r\\n print(\\\"Is this data already cleaned?\\\\nMandatory columns for cleaning not present in data!\\\")\\r\\n print(\\\"Returning provided dataframe!\\\")\\r\\n return df\\r\\n df = df[(df['Potential contaminant'].isnull()) &\\r\\n (df['Reverse'].isnull()) &\\r\\n (df['Only identified by site'].isnull())]\\r\\n df.drop(['Potential contaminant',\\\"Reverse\\\", 'Only identified by site'], axis=1, inplace=True)\\r\\n elif (file == \\\"Phospho (STY)\\\") or (file == \\\"evidence\\\") or (file == \\\"modificationSpecificPeptides\\\"):\\r\\n if (\\\"Potential contaminant\\\" not in columns) or\\\\\\r\\n (\\\"Reverse\\\" not in columns):\\r\\n print(\\\"Is this data already cleaned?\\\\nMandatory columns for cleaning not present in data!\\\")\\r\\n print(\\\"Returning provided dataframe!\\\")\\r\\n return df\\r\\n df = df[(df['Potential contaminant'].isnull()) &\\r\\n (df['Reverse'].isnull())]\\r\\n df.drop(['Potential contaminant',\\\"Reverse\\\"], axis=1, inplace=True)\\r\\n return df\",\n \"def df_cleaner(df):\\n return df.dropna()\",\n \"def _filter(self, col: str, val: Any) -> pd.DataFrame:\\n return self._df[self._df[col] == val]\",\n \"def fixed(df: pd.DataFrame, fixers: dict, not_equal=False) -> pd.DataFrame:\\n selector = None\\n for k, v in fixers.items():\\n if selector is None:\\n if not_equal:\\n selector = (df[k] != v)\\n else:\\n selector = (df[k] == v)\\n else:\\n if not_equal:\\n selector = np.logical_and(selector, df[k] != v)\\n else:\\n selector = np.logical_and(selector, df[k] == v)\\n if selector is None:\\n return df.copy()\\n else:\\n return df[selector].reset_index(drop=True).copy()\",\n \"def cleaned(df):\\n\\n cdf = df.copy()\\n lcdf = len(cdf)\\n\\n danglings = []\\n ld = len(danglings)\\n\\n print('cleaning data frame')\\n iteration_times = 1\\n while True:\\n for index, row in cdf.iterrows():\\n if index in danglings:\\n cdf = cdf.drop(index)\\n elif not (cdf['from'] == row['to']).any():\\n danglings.append(index)\\n cdf = cdf.drop(index)\\n\\n if not index % 77:\\n print(f'{del_line}{index / lcdf * 100:2.1f}% #{iteration_times}', end='')\\n iteration_times += 1\\n\\n # iterate until `danglings` does not change\\n if len(danglings) == ld:\\n break\\n else:\\n ld = len(danglings)\\n\\n print(f'{del_line}data cleaned with {iteration_times} iterations')\\n\\n return cdf, np.array(danglings)\",\n \"def _get_target_only_columns(self, df: DataFrame) -> DataFrame:\\n target_table_columns = self.target_table.get_columns()\\n \\n # if mutation of incoming df is desired, make a deepcopy here\\n filtered_df = df\\n for column in filtered_df.columns:\\n if column not in target_table_columns:\\n print(f'dropping unused column \\\"{column}\\\"')\\n filtered_df = filtered_df.drop(column)\\n \\n return filtered_df\",\n \"def query(df: pd.DataFrame) -> pd.DataFrame:\\n pydref = pdref.Pydref()\\n logger = get_logger(threading.current_thread().name)\\n logger.info(\\\"start\\\")\\n part_idref = {\\\"person_id\\\": [], \\\"name_corrected\\\": [], \\\"idref\\\": []}\\n for _, r in df.iterrows():\\n try:\\n result = pydref.identify(r[\\\"name_corrected\\\"])\\n if result.get(\\\"status\\\") == \\\"found\\\":\\n part_idref[\\\"person_id\\\"].append(r[\\\"person_id\\\"])\\n part_idref[\\\"name_corrected\\\"].append(r[\\\"name_corrected\\\"])\\n part_idref[\\\"idref\\\"].append(result.get(\\\"idref\\\"))\\n except:\\n pass\\n\\n df = pd.DataFrame(data=part_idref)\\n df[\\\"person_id\\\"] = df[\\\"person_id\\\"].astype(pd.Int64Dtype())\\n logger.info(\\\"end\\\")\\n\\n return df\",\n \"def _filter_data(self, pattern):\\n removed = []\\n filtered = []\\n for param in self.data:\\n if not param[0].startswith(pattern):\\n filtered.append(param)\\n else:\\n removed.append(param)\\n self.data = filtered\\n return removed\",\n \"def drop_transactions(df, station, access_point = None):\\n\\n if access_point is not None:\\n station_name = df.nombreestacion.contains(station)\\n entrance = df.nombreaccesoestacion.contains(access_point)\\n filters = station_name & entrance\\n else:\\n filters = df.nombreestacion.contains(station)\\n return df.filter(~filters)\",\n \"def filter_data(self):\\n self.df = self.df[HeatStrokeDataFiller.important_features]\",\n \"def clean_data(input_df, output_df):\\n all_rows = pd.concat([input_df, output_df], axis=1)\\n all_rows.dropna(how='all', inplace=True)\\n input_df = all_rows.iloc[:, 0:input_df.shape[1]]\\n output_df = all_rows.iloc[:, input_df.shape[1]:all_rows.shape[1]]\\n return input_df, output_df\",\n \"def filter_by_isin(df: pd.DataFrame, column: str, values: Iterable) -> pd.DataFrame:\\n # First, create a \\\"map\\\" series from all possible values in the column => whether they should pass the filter\\n all_ids = df[column].unique()\\n is_id_relevant = pd.Series(np.zeros(len(all_ids)), index=all_ids).astype('bool') # Default false\\n is_id_relevant.loc[values] = True\\n\\n # Create a boolean mask for column, based on the mapping above. Grab the raw array.\\n mask = is_id_relevant[df[column]].values\\n # Apply mask\\n return df[mask]\",\n \"def remove_players_wo_positions(df):\\n df = df[pd.notnull(df['FantPos'])]\\n return df\",\n \"def filter_df(df, month, day):\\n\\n #filter by month\\n df = df.loc[df['month'] == month]\\n\\n #filter by day\\n df = df.loc[df['day_of_week'] == day]\\n\\n return df\",\n \"def drop_uniform_slice_from_dataframe(df, value, axis=0):\\n\\n if axis == 0:\\n dropped = (df == value).all(axis=0)\\n if any(dropped):\\n print('Removed {} column index(ices) whose values are all {}.'.\\n format(dropped.sum(), value))\\n return df.ix[:, ~dropped]\\n\\n elif axis == 1:\\n dropped = (df == value).all(axis=1)\\n if any(dropped):\\n print('Removed {} row index(ices) whose values are all {}.'.format(\\n dropped.sum(), value))\\n return df.ix[~dropped, :]\",\n \"def column_eliminate(values):\\n solved_values = [box for box in values.keys() if len(values[box]) == 1]\\n for box in solved_values:\\n \\n location = values[box][0] #a solved location in a column\\n if location in location_dict.keys():\\n \\n #ensure that multiple groups can be in multiple locations using period_loc_frequency\\n loc_freq = 0\\n loc_freq -= 1 #subtract one for the current location usage\\n loc_freq += period_loc_frequency[location]\\n \\n for other_col in column_dict[box]:\\n if other_col in solved_values:\\n if values[other_col] == location:\\n loc_freq -= 1\\n \\n #make sure that too many locations haven't been used up yet\\n if loc_freq < 0:\\n print(\\\"error: too many groups in location\\\", location)\\n \\n #if the location is \\\"used up\\\", remove it as an option from the rest of the groups\\n if loc_freq == 0:\\n for other_col in column_dict[box]:\\n try:\\n values[other_col].remove(location) #remove the location from the other column units\\n except:\\n pass\\n \\n return values\",\n \"def filter_values(df, value=0, axis=0):\\n \\n if axis:\\n return df.loc[:, (df != value).any(axis=1-axis)]\\n else:\\n return df.loc[(df != value).any(axis=1-axis)]\",\n \"def filterfeatures(df):\\n\\tfilter_arr = []\\n\\tfor f in df.columns:\\n\\t\\tif not '.l' in f and not '.r' in f and not '.std' in f and f != 'weight' and f != 'class':\\n\\t\\t\\t# filter_arr.append(f.rstrip('.mean'))\\n\\t\\t\\tfilter_arr.append(f)\\n\\treturn filter_arr\",\n \"def exclude(requestContext, seriesList, pattern):\\n regex = re.compile(pattern)\\n return [s for s in seriesList if not regex.search(s.name)]\",\n \"def filter_by_names(df, names_list):\\n return df.ix[names_list]\",\n \"def clean_data(df):\\n \\n any_location_id_missing = (df.PULocationID > 263) | (df.DOLocationID > 263)\\n df = df.drop(df.index[any_location_id_missing])\\n \\n df = df[df.tpep_dropoff_datetime > df.tpep_pickup_datetime]\\n\\n df.PULocationID.replace([104, 105], 103)\\n \\n return df\",\n \"def _truncate_games_df(df, season, season_type):\\n return df[(df['season'] != season) | (df['type'] != season_type)]\",\n \"def filter_dataframe_by_composition(df, composition, formula_column=\\\"Composition\\\"):\\n # Get elements in formula, composition, then filter\\n chemsys = set(Composition(composition).keys())\\n all_comps = df[formula_column].apply(Composition)\\n indices_to_include = [ind for ind, comp in all_comps.items()\\n if comp.keys() <= chemsys]\\n return df.loc[indices_to_include]\",\n \"def df_cleaner(df):\\n df = df.dropna()\\n return df\",\n \"def get_valid_passwords(df, validation_method):\\n # list of indices that should be dropped\\n drop = []\\n\\n # find all invalid passwords\\n for i in range(len(df.index)):\\n if not validation_method(df.iloc[i]):\\n drop.append(i)\\n\\n # drop invalid passwords and return dataframe\\n return df.drop(drop).reset_index(drop=True)\",\n \"def get_compound_df(df):\\n columns = {'Name':'analyte', 'Amount': 'measurement'}\\n df['Compound'].rename(columns=columns, inplace=True)\\n df_compound = df['Compound'].copy()\\n df_compound.loc[(df_compound.analyte.isnull()) & (df_compound.measurement > 0), 'analyte'] = 'wildcard'\\n df_compound.dropna(subset = ['analyte'], inplace=True)\\n return df_compound\",\n \"def remove_blank_rows(df):\\n clean_df = df.filter(df.columns[1:], axis=1).dropna(how='all', axis=0)\\n idx_to_keep = clean_df.index\\n clean_df = df.filter(idx_to_keep, axis=0)\\n return clean_df\",\n \"def filter_data(df, needed_columns, not_null_columns=[]):\\n\\n if all(x in needed_columns for x in not_null_columns):\\n\\n df = get_needed_columns(df, needed_columns)\\n #Use the pandas method bc the other method was erroring on boolean index.\\n #IM - 9/23/22\\n df = df.dropna(subset=not_null_columns)#remove_rows_with_null_values(df, not_null_columns)\\n\\n return df\\n else:\\n print(\\\"Developer error, not null columns should be a subset of needed columns\\\")\\n return df\",\n \"def get_world_df(df: pd.DataFrame) -> pd.DataFrame:\\n\\n return df[\\n df[Columns.LOCATION_NAME].isin(\\n [Locations.WORLD, Locations.WORLD_MINUS_CHINA, Locations.CHINA]\\n )\\n ]\",\n \"def standart_filter(left_df, right_df):\\n return left_df.join(right_df, left_df.tconst == right_df.tconst) \\\\\\n .drop(right_df.tconst) \\\\\\n .filter((left_df.titleType == 'movie')\\n & (right_df.numVotes >= 100000))\",\n \"def search_premade(phrase = '*',\\n language = 'en',\\n url = 'http://data.ssb.no/api/v0/dataset'):\\n url = '{url}?lang={language}'.format(\\n url = url,\\n language = language)\\n \\n df = pd.read_html(url)\\n df = df[0]\\n df.index = df['ID']\\n df = df.iloc[:,[0,1]]\\n df = df.sort_index()\\n phrase = phrase.lower()\\n \\n if phrase != '*':\\n df = df[(df.iloc[:,0].str.lower().str.contains(phrase)) | \\n (df.iloc[:,1].str.lower().str.contains(phrase)) ]\\n return df\",\n \"def _query_df(self, opt: dict):\\n query = []\\n for k in self.unique_keys:\\n val = opt[k]\\n if isinstance(val, str):\\n query.append(f\\\"{k}=='{val}'\\\")\\n else:\\n query.append(f\\\"{k}=={val}\\\")\\n return self.data.query(\\\" and \\\".join(query).strip())\",\n \"def _description_filter(self, df):\\n df = df[df['Description'].str.contains(\\\"and\\\")]\\n df['Description'] = df['Description'].map(lambda x: x[:MAX_DESC_LENGTH])\\n return df\",\n \"def filter_rows(self, **kwargs):\\n filtered = self._data.copy()\\n for colname, values in kwargs.items():\\n values = [values] if type(values) == str else values\\n filtered = filtered[filtered[colname].isin(values)]\\n return self._copy(filtered)\",\n \"def normData( df, inSirenName=\\\"./siren_in.csv\\\", gtName=\\\"./Greentech_All_VF4_green.xlsx\\\", gt_sheet_name=\\\"FICHIER COMPLET\\\" ) :\\n sirens_g = pd.read_excel( gtName, gt_sheet_name)[\\\"SIREN\\\"].tolist()\\n print( \\\"Number of known GreenTechs:\\\", len(sirens_g))\\n\\n sirens = pd.read_csv( inSirenName )[\\\"siren\\\"].tolist()\\n print(\\\"Number of whole eligible companies:\\\", len(sirens))\\n\\n return df[ ( df[\\\"SIREN\\\"].isin( sirens ) ) & ( ~df[\\\"SIREN\\\"].isin( sirens_g ) ) ]\",\n \"def clean_up_raw(df_raw):\\n # exclude_subset = ['well', 'tile', 'cell', 'intensity', 'blob'] # causes issues with later joins, maybe a pandas bug\\n import lasagna.utils\\n df_raw[CYCLE] = df_raw[CYCLE].astype(int)\\n df_raw = df_raw.sort_values([WELL, TILE, CELL, BLOB, CYCLE, CHANNEL])\\n return df_raw\",\n \"def filter_rows(self, **kwds):\\n if kwds:\\n normalize = lambda v: (v,) if isinstance(v, str) else v\\n kwds = dict((k, normalize(v)) for k, v in kwds.items())\\n matches_kwds = lambda row: all(row[k] in v for k, v in kwds.items())\\n return filter(matches_kwds, self.__iter__())\\n return self.__iter__()\",\n \"def filterRows(function, rows):\\n return [y for y in rows if function(y)]\",\n \"def remove_guides(df, rm_guides):\\n df = df[~(df.anchor_guide.isin(rm_guides))]\\n return df\",\n \"def result_df(self, regex=None) -> pd.DataFrame:\\n if regex:\\n # get one random item from dict, and get keys from this random (dict) item\\n # FIXME: how to do this better? - this is not efficient...\\n keys = self.result[next(iter(self.result))].keys()\\n\\n if type(regex) == str:\\n comp_regexe = re.compile(regex)\\n columns = list(filter(comp_regexe.search, keys))\\n else:\\n columns = list(filter(regex.search, keys))\\n\\n df = pd.DataFrame.from_dict(self.result, orient='index')\\n return df[columns]\\n else:\\n return pd.DataFrame.from_dict(self.result, orient='index')\",\n \"def subsetmask(df, mask_df = get_contest_mask()):\\n return pd.merge(df, mask_df, on=['lat', 'lon'], how='inner')\",\n \"def _filter_valid_id(df, col):\\n df = df[(df[col].str.isnumeric().replace({np.nan: False})) &\\n (df[col] != '0') &\\n (df[col] != 0)]\\n return df\",\n \"def clean_ferc714_hourly_demand_matrix(df: pd.DataFrame) -> pd.DataFrame:\\n ts = pudl.analysis.timeseries_cleaning.Timeseries(df)\\n ts.flag_ruggles()\\n return ts.to_dataframe(copy=False)\",\n \"def searchable_data(df, columns):\\n df['searchable_data'] = df[columns].apply(lambda x: ' '.join(x), axis=1)\\n df = df.drop(columns, axis=1)\\n df['searchable_data'] = df['searchable_data'].map(clean_data)\\n return df\",\n \"def filter_hets(gens_df):\\n\\tgenotype_cols = list(set(gens_df.columns).difference(set(['chrom', 'pos', 'ref', 'alt'])))\\n\\tgens_df['het'] = gens_df.apply(lambda row: any(het(row[col]) for col in genotype_cols), axis=1)\\n\\tout = gens_df.query('het')[['chrom', 'pos', 'ref', 'alt']+genotype_cols]\\n\\treturn out\",\n \"def get_rxn_subset(input_hdf5, rxn_df_key):\\n rxn_df = pd.read_hdf(input_hdf5, rxn_df_key)\\n # Subset filtering criteria; can be updated as required\\n # For instance, when the Pubchem ids of all the chemicals with score >= 50 have been fetched,\\n # Status75 below can be chnaged to Status 50. Currently, all the chemicals with scores >= 90\\n # have been fetched\\n rxn_df = rxn_df.query(\\\"Products_Available == True & Status_75 == True\\\")\\n\\n # Now we will get rid of all the rows that have 'NaN' in their CID list or if they have any adduct\\n to_be_dropped = []\\n for idx, row in rxn_df.iterrows():\\n cid_list = row['ReactantCID'] + row['ProductCID']\\n for ele in cid_list:\\n if math.isnan(ele) or re.search(\\\"adduct\\\", row['Reactants']+row['Products'], re.IGNORECASE):\\n to_be_dropped.append(idx)\\n break\\n\\n rxn_df = rxn_df.drop(to_be_dropped)\\n return rxn_df\",\n \"def subsetmask(df, mask_df):\\r\\n return pd.merge(df, mask_df, on=['lat', 'lon'], how='inner')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67580104","0.61284876","0.59954125","0.5946802","0.5877959","0.5857522","0.5824286","0.57481945","0.57481945","0.5692505","0.56695396","0.5544663","0.55146563","0.5502974","0.54838765","0.54560864","0.54314256","0.5424039","0.5391558","0.53590816","0.5323305","0.53208524","0.5313805","0.5310662","0.53092474","0.5287976","0.52514154","0.5244534","0.52442133","0.5229888","0.52201456","0.5200345","0.5184434","0.517997","0.5175311","0.51742053","0.5164786","0.51501584","0.51462376","0.5134395","0.513433","0.5126032","0.5123309","0.5116553","0.5111686","0.51101166","0.51090467","0.510762","0.5105927","0.5084055","0.5081278","0.50778484","0.50777984","0.5070575","0.5058339","0.50365025","0.5022783","0.502186","0.50069344","0.49980444","0.49857223","0.49584356","0.49569854","0.4945563","0.49426433","0.49324092","0.49209052","0.4914681","0.49127576","0.4899099","0.48930287","0.48928332","0.48925567","0.48766738","0.48509294","0.4847455","0.48319107","0.48275727","0.4822017","0.48214412","0.48113868","0.4811083","0.48040122","0.4802069","0.47888958","0.47864705","0.47818398","0.47710028","0.47691968","0.4746584","0.4745089","0.47438344","0.4742435","0.47414225","0.47413638","0.47229335","0.4721862","0.47199216","0.4718173","0.47170308"],"string":"[\n \"0.67580104\",\n \"0.61284876\",\n \"0.59954125\",\n \"0.5946802\",\n \"0.5877959\",\n \"0.5857522\",\n \"0.5824286\",\n \"0.57481945\",\n \"0.57481945\",\n \"0.5692505\",\n \"0.56695396\",\n \"0.5544663\",\n \"0.55146563\",\n \"0.5502974\",\n \"0.54838765\",\n \"0.54560864\",\n \"0.54314256\",\n \"0.5424039\",\n \"0.5391558\",\n \"0.53590816\",\n \"0.5323305\",\n \"0.53208524\",\n \"0.5313805\",\n \"0.5310662\",\n \"0.53092474\",\n \"0.5287976\",\n \"0.52514154\",\n \"0.5244534\",\n \"0.52442133\",\n \"0.5229888\",\n \"0.52201456\",\n \"0.5200345\",\n \"0.5184434\",\n \"0.517997\",\n \"0.5175311\",\n \"0.51742053\",\n \"0.5164786\",\n \"0.51501584\",\n \"0.51462376\",\n \"0.5134395\",\n \"0.513433\",\n \"0.5126032\",\n \"0.5123309\",\n \"0.5116553\",\n \"0.5111686\",\n \"0.51101166\",\n \"0.51090467\",\n \"0.510762\",\n \"0.5105927\",\n \"0.5084055\",\n \"0.5081278\",\n \"0.50778484\",\n \"0.50777984\",\n \"0.5070575\",\n \"0.5058339\",\n \"0.50365025\",\n \"0.5022783\",\n \"0.502186\",\n \"0.50069344\",\n \"0.49980444\",\n \"0.49857223\",\n \"0.49584356\",\n \"0.49569854\",\n \"0.4945563\",\n \"0.49426433\",\n \"0.49324092\",\n \"0.49209052\",\n \"0.4914681\",\n \"0.49127576\",\n \"0.4899099\",\n \"0.48930287\",\n \"0.48928332\",\n \"0.48925567\",\n \"0.48766738\",\n \"0.48509294\",\n \"0.4847455\",\n \"0.48319107\",\n \"0.48275727\",\n \"0.4822017\",\n \"0.48214412\",\n \"0.48113868\",\n \"0.4811083\",\n \"0.48040122\",\n \"0.4802069\",\n \"0.47888958\",\n \"0.47864705\",\n \"0.47818398\",\n \"0.47710028\",\n \"0.47691968\",\n \"0.4746584\",\n \"0.4745089\",\n \"0.47438344\",\n \"0.4742435\",\n \"0.47414225\",\n \"0.47413638\",\n \"0.47229335\",\n \"0.4721862\",\n \"0.47199216\",\n \"0.4718173\",\n \"0.47170308\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7941567"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":12879,"cells":{"query":{"kind":"string","value":"get data for just one gene (assay) to closer inspect data"},"document":{"kind":"string","value":"def get_detailed_ddct_data(self, assay):\n df = self.ddct.query(\"Assay == '{}'\".format(assay)).reset_index(drop=True)\n return pandas.pivot_table(df, values=0, columns='time', index=['cell_line', 'treatment', 'replicate'])"},"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 gene(self, idx):\r\n return self.genes[idx]","async def test_get_gene_from_ac(test_db):\n resp = await test_db.get_gene_from_ac(\"NC_000007.13\", 140453136, None)\n assert resp == [\"BRAF\"]\n\n resp = await test_db.get_gene_from_ac(\"NC_000007.14\", 140753336, None)\n assert resp == [\"BRAF\"]\n\n resp = await test_db.get_gene_from_ac(\"NC_000007.13\", 55249071, None)\n assert resp == [\"EGFR\", \"EGFR-AS1\"]\n\n resp = await test_db.get_gene_from_ac(\"NC_0000078.1\", 140453136, None)\n assert resp is None","def get_entrezid(gene):\n entrezurl = \"http://mygene.info/v3/query?q=\"\n entrezurl = entrezurl+gene\n\n res = requests.get(entrezurl)\n results = pandas.read_json(StringIO(res.text))\n\n entrezid = []\n if results.empty:\n return entrezid\n\n for i in results.ix[:, 0]:\n key = i.keys()\n value = i.values()\n for cntr, k in enumerate(key):\n if k == 'entrezgene':\n entrezid.append(value[cntr])\n return entrezid","def GetGeData(self, *args, **kwargs):\n pass","def get_gene(gene):\n\n return copy.deepcopy(gene)","def init_gene():\n gene_details=dict(\n id = '', \n anno_id = [],\n confgenes_id = [],\n name = '',\n source = '',\n gene_info = {},\n alias = '',\n name2 = [],\n strand = '',\n chr = '',\n chr_num = [],\n paralogs = [],\n start = '',\n stop = '',\n transcripts = [],\n transcript_info = [],\n transcript_status = [],\n transcript_valid = [],\n exons = [],\n exons_confirmed = [],\n cds_exons = [],\n utr5_exons = [],\n utr3_exons = [],\n tis = [],\n tis_conf = [],\n tis_info = [],\n cdsStop = [],\n cdsStop_conf = [],\n cdsStop_info = [],\n tss = [],\n tss_info = [],\n tss_conf = [],\n cleave = [],\n cleave_info = [],\n cleave_conf = [],\n polya = [],\n polya_info = [],\n polya_conf = [],\n is_alt = [],\n is_alt_spliced = 0,\n is_valid = [],\n transcript_complete = [],\n is_complete = [],\n is_correctly_gff3_referenced = '',\n splicegraph = []\n )\n return gene_details","def get_data():\n pass","def get_gene(self):\n return self._gene","def read_dataset_v1():\n path = load_config()\n T = feather.read_dataframe(path['data_dir'] / 'T_dat.feather')\n E = feather.read_dataframe(path['data_dir'] / 'E_dat.feather')\n M = feather.read_dataframe(path['data_dir'] / 'Meta.feather')\n data = sio.loadmat(path['data_dir'] / 'highvar_genes.mat', squeeze_me=True)\n return T, E, M, data","def get_results(self, preprocess=True):\n logger.debug('Calculating GSEA')\n measurement_df = self._get_measurement_df(preprocess)\n\n annot_df = self.data_source.get_annotations()\n joined = pd.merge(left=measurement_df, right=annot_df, left_index=True, right_index=True)\n joined = joined.set_index('entity_id')\n unique_ids = [self.data_source._get_unique_id(x) for x in joined.index.values]\n joined.index = unique_ids\n joined = joined.drop_duplicates(keep='first').sort_index()\n\n # gene_sets is a dict. key is pw name, values are a list of entries in that pathway\n gene_sets = {}\n assert len(self.data_source.dataset_pathways) > 0, 'No pathways found in the dataset'\n pathways = list(self.data_source.dataset_pathways)\n for pw in pathways:\n pathway_row_ids = self.data_source.dataset_pathways_to_row_ids[pw]\n pw_unique_ids = []\n for row_id in pathway_row_ids:\n pw_unique_ids.extend(self.data_source.dataset_row_id_to_unique_ids[row_id])\n pw_unique_ids = list(set(pw_unique_ids))\n gene_sets[pw] = pw_unique_ids\n\n # run GSEA for all comparisons\n all_dfs = []\n for comp in self.data_source.comparisons:\n if not is_comparison_used(comp, self.case, self.control):\n continue\n case = comp['case']\n control = comp['control']\n logger.debug('Running comparison case=%s control=%s' % (case, control))\n pheno_cols = set(self.data_source.get_experimental_design()['groups'][case])\n df_cols = measurement_df.columns.values\n\n # for each comparison, we need to create C (phenotype labels)\n # Loop over df_cols and store an indicator into C.\n # Entries in C is 1 if that column belongs to the case group, otherwise it's a 0\n C = []\n for col in df_cols:\n if col in pheno_cols:\n C.append(1)\n else:\n C.append(0)\n C = np.array(C)\n\n # actually runs GSEA here\n data = joined\n cls = C.tolist()\n outdir = None\n min_size = 1\n max_size = 1000\n permutation_num = self.num_resamples\n weighted_score_type = 1\n permutation_type = 'phenotype'\n method = self.method\n ascending = True\n processes = 1\n figsize = (6.5, 6)\n format = 'pdf',\n graph_num = 20\n no_plot = True\n seed = None\n verbose = False\n\n msea = MSEA(data, gene_sets, cls, outdir, min_size, max_size, permutation_num,\n weighted_score_type, permutation_type, method, ascending, processes,\n figsize, format, graph_num, no_plot, seed, verbose)\n msea.run()\n\n # convert GSEA results to dataframe\n df = msea.res2d\n df = df.reset_index()\n selected = df[['Term', 'pval', 'fdr', 'es']]\n selected = selected.rename(columns={'Term': 'mapids'}).set_index('mapids')\n\n col_name = comp['name'] + ' p-value'\n es_colname = comp['name'] + ' ES_score'\n if self.data_source.database_name is not None:\n comb_col_name = '%s %s %s' % (self.data_source.database_name, comp['name'], 'comb_p')\n else:\n comb_col_name = '%s %s' % (comp['name'], 'comb_p')\n\n pathway_df = selected.rename(columns={\n 'pval': col_name,\n 'es': es_colname,\n 'fdr': comb_col_name\n })\n all_dfs.append(pathway_df)\n\n # combine all the results across all comparisons\n combined_df = pd.concat(all_dfs, axis=1, sort=False)\n combined_df.index.name = 'mapids'\n\n # create a dataframe of pathway mapids and names\n pw_name_df = []\n for map_id in pathways:\n pw_name = self.data_source.pathway_dict[map_id]['display_name']\n pw_name_df.append((map_id, pw_name))\n pw_name_df = pd.DataFrame(pw_name_df, columns=['mapids', 'pw_name']).set_index(['mapids'])\n combined_df = pw_name_df.merge(combined_df, left_index=True, right_index=True)\n\n # add formula coverage information\n mapids = combined_df.index.values.tolist()\n cov_df = self.data_source._calculate_coverage_df(mapids)\n coverage_df = cov_df.reindex(combined_df.index) # make sure dfs are in same order before merging\n\n # Merge the two dfs together\n pathway_df = pd.merge(combined_df, coverage_df, left_index=True, right_index=True, how='outer')\n\n # del pathway_df.index.name\n pathway_df.rename_axis(None, inplace=True)\n\n # post-processing to filter pathway dataframe by the minimum number of hits\n pathway_df = post_filter_df_by_min_hits(pathway_df, self.data_source.min_hits)\n return pathway_df","def extract_gene_data(info):\n gene_id = None\n gene_type = None\n for i in info:\n if i.startswith('gene_id'):\n gene_id = i.split(\" \", 1)[1].replace('\"', '')\n elif i.startswith('gene_type'):\n gene_type = i.split(\" \", 1)[1].replace('\"', '')\n\n assert gene_id is not None, 'No gene_id found {0}'.format(info)\n assert gene_type is not None, 'No gene_type found {0}'.format(info)\n return gene_id, gene_type","def get_gene_snatac_from_mysql(ensemble, gene_table_name, counts_type, tsne_type, max_points='10000', modality='snATAC'):\n\n\tt0=datetime.datetime.now()\n\tif tsne_type=='noTSNE':\n\t\tquery = \"SELECT %(gene_table_name)s.%(counts_type)s as normalized_counts \\\n\t\t\tFROM %(ensemble)s \\\n\t\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \" % {'ensemble': ensemble, \n\t\t\t 'gene_table_name': gene_table_name,\n\t\t\t 'counts_type': counts_type,}\n\telse:\n\t\tquery = \"SELECT cells.cell_id, cells.cell_name, cells.dataset, \\\n\t\t\t%(ensemble)s.annotation_%(modality)s, %(ensemble)s.cluster_%(modality)s, \\\n\t\t\t%(ensemble)s.tsne_x_%(modality)s, %(ensemble)s.tsne_y_%(modality)s, \\\n\t\t\t%(gene_table_name)s.%(counts_type)s as normalized_counts, \\\n\t\t\tdatasets.target_region \\\n\t\t\tFROM cells \\\n\t\t\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\n\t\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\n\t\t\tLEFT JOIN datasets ON cells.dataset = datasets.dataset\" % {'ensemble': ensemble,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'gene_table_name': gene_table_name,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'counts_type': counts_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'modality': modality,}\n\tif max_points.isdigit():\n\t\tquery = query+\" ORDER BY RAND() LIMIT %(max_points)s\" % {'max_points': max_points}\n\n\ttry:\n\t\tdf = pd.read_sql(query, db.get_engine(current_app, modality+'_data'))\n\texcept exc.ProgrammingError as e:\n\t\tnow = datetime.datetime.now()\n\t\tprint(\"[{}] ERROR in app(get_gene_snatac_from_mysql): {}\".format(str(now), e))\n\t\tsys.stdout.flush()\n\t\treturn None\n\n\tt1=datetime.datetime.now()\n\n\treturn df","def extract_data( galaxy_ID):\n\n data_cube = marvin.tools.Maps( galaxy_ID)\n\n #ssp = main_file[1].data\n #flux_elines = main_file[3].data\n #org_hdr = main_file[0].header\n\n ###########################################################################\n # NOTE: The visual band fluxes are multiplied by 10^-16 as stated in the\n # units of the MaNGA Data Model.\n #\n # <https://data.sdss.org/datamodel/files/MANGA_PIPE3D/MANGADRP_VER\n # /PIPE3D_VER/PLATE/manga.Pipe3D.cube.html#hdu1>\n ###########################################################################\n #v_band = ssp[0] # in units of erg / s / cm^2\n #v_band_err = ssp[4] # in units of erg / s / cm^2\n #sMass_density = ssp[19] * u.dex( u.M_sun) # in units of log10( Msun / spaxel**2)\n\n Ha_vel = data_cube.emlines_gvel_ha_6564 # in units of km/s\n Ha_vel_err = data_cube.emlines_g # in units of km/s\n\n manga_plate = org_hdr['PLATEID']\n manga_fiberID = org_hdr['IFUDSGN']\n gal_ra = org_hdr['OBJRA']\n gal_dec = org_hdr['OBJDEC']\n\n return Ha_vel, Ha_vel_err, v_band, v_band_err, sMass_density, manga_plate, \n manga_fiberID, gal_ra, gal_dec","def getFirstData(self) -> ghidra.program.model.listing.Data:\n ...","def get_data():\n return","def data(self):\n return self._data.iloc[:, : self.n_genes]","def _get_gedi1b_main_data_dict(self) -> dict:\n data = {\n # General identifiable data\n \"granule_name\": [self.parent_granule.filename] * self.n_shots,\n \"shot_number\": self[\"shot_number\"][:],\n \"beam_type\": [self.beam_type] * self.n_shots,\n \"beam_name\": [self.name] * self.n_shots,\n # Temporal data\n \"delta_time\": self[\"delta_time\"][:],\n # Quality data\n \"degrade\": self[\"geolocation/degrade\"][:],\n \"stale_return_flag\": self[\"stale_return_flag\"][:],\n \"solar_elevation\": self[\"geolocation/solar_elevation\"][:],\n \"solar_azimuth\": self[\"geolocation/solar_elevation\"][:],\n \"rx_energy\": self[\"rx_energy\"][:],\n # DEM\n \"dem_tandemx\": self[\"geolocation/digital_elevation_model\"][:],\n \"dem_srtm\": self[\"geolocation/digital_elevation_model_srtm\"][:],\n # geolocation bin0\n \"latitude_bin0\": self[\"geolocation/latitude_bin0\"][:],\n \"latitude_bin0_error\": self[\"geolocation/latitude_bin0_error\"][:],\n \"longitude_bin0\": self[\"geolocation/longitude_bin0\"][:],\n \"longitude_bin0_error\": self[\"geolocation/longitude_bin0_error\"][:],\n \"elevation_bin0\": self[\"geolocation/elevation_bin0\"][:],\n \"elevation_bin0_error\": self[\"geolocation/elevation_bin0_error\"][:],\n # geolocation lastbin\n \"latitude_lastbin\": self[\"geolocation/latitude_lastbin\"][:],\n \"latitude_lastbin_error\": self[\"geolocation/latitude_lastbin_error\"][:],\n \"longitude_lastbin\": self[\"geolocation/longitude_lastbin\"][:],\n \"longitude_lastbin_error\": self[\"geolocation/longitude_lastbin_error\"][:],\n \"elevation_lastbin\": self[\"geolocation/elevation_lastbin\"][:],\n \"elevation_lastbin_error\": self[\"geolocation/elevation_lastbin_error\"][:],\n # relative waveform position info in beam and ssub-granule\n \"waveform_start\": self[\"rx_sample_start_index\"][:] - 1,\n \"waveform_count\": self[\"rx_sample_count\"][:],\n }\n return data","def test_get_genome_7(self):\n self.tkt1.data_add = set([\"retrieve_record\"])\n gnm = tickets.get_genome(self.tkt1, gnm_type=\"add\")\n with self.subTest():\n self.assertEqual(gnm.host_genus, \"\")\n with self.subTest():\n self.assertEqual(gnm.retrieve_record, 1)","def get_mult_gene_snATAC(ensemble, genes, grouping, smoothing=False, max_points='10000', modality='snATAC'):\n\n\t# Prevent SQL injected since column names cannot be parameterized.\n\tif \";\" in ensemble or \";\" in grouping:\n\t\treturn None\n\n\tgenes = [gene+\"%\" for gene in genes]\n\n\t# This query is just to fix gene id's missing the ensemble version number.\n\t# Necessary because the table name must match exactly with whats on the MySQL database.\n\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3\n\tfirst_query = \"SELECT gene_id FROM genes WHERE gene_id LIKE %s\" + \" OR gene_id LIKE %s\" * (len(genes)-1)\n\tresult = db.get_engine(current_app, 'methylation_data').execute(first_query, (genes,)).fetchall()\n\n\tgene_table_names = ['gene_' + gene_id[0].replace('.','_') for gene_id in result]\n\n\tdf_all = pd.DataFrame()\n\n\tif smoothing:\n\t\tcounts_type='smoothed_normalized_counts'\n\telse:\n\t\tcounts_type='normalized_counts'\n\n\tt0=datetime.datetime.now()\n\tdf_list = []\n\tdf = get_gene_snatac_from_mysql(ensemble, gene_table_names[0], counts_type, 'TSNE', max_points)\n\tdf_all = df_all.append(df)\n\tdf_coords = df;\n\tfor gene_table_name in gene_table_names[1:]:\n\t\tdf_all = df_all.append(get_gene_snatac_from_mysql(ensemble, gene_table_name, counts_type, 'noTSNE', max_points))\n\n\tt1=datetime.datetime.now()\n\n\tt1=datetime.datetime.now()\n\n\tif df_all.empty: # If no data in column, return None\n\t\tnow = datetime.datetime.now()\n\t\tprint(\"[{}] ERROR in app(get_gene_snATAC): No snATAC data for {}\".format(str(now), ensemble))\n\t\tsys.stdout.flush()\n\t\treturn None\n\n\tdf_all['normalized_counts'].fillna(0, inplace=True)\n\n\tdf_avg_methylation = df_all.groupby(by='cell_id', as_index=False)['normalized_counts'].mean()\n\tdf_coords.update(df_avg_methylation)\n\n\tif grouping == 'annotation':\n\t\tdf_coords.fillna({'annotation_ATAC': 'None'}, inplace=True)\n\t\tdf_coords['annotation_cat'] = pd.Categorical(df_coords['annotation_ATAC'], cluster_annotation_order)\n\t\tdf_coords.sort_values(by='annotation_cat', inplace=True)\n\t\tdf_coords.drop('annotation_cat', axis=1, inplace=True)\n\telif grouping == 'cluster':\n\t\tdf_coords.sort_values(by='cluster_ATAC', inplace=True)\n\treturn df_coords","def get_gene_snATAC(ensemble, gene, grouping, outliers, smoothing=False, max_points='10000', \n\tmodality='snATAC'):\n\tmodalityu = modality.replace('snATAC','ATAC').replace('snRNA','RNA')\n\n\t# Prevent SQL injected since column names cannot be parameterized.\n\tif \";\" in ensemble or \";\" in grouping:\n\t\treturn None\n\n\t# This query is just to fix gene id's missing the ensemble version number.\n\t# Necessary because the table name must match exactly with whats on the MySQL database.\n\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3 -> gene_ENSMUSG00000026787_3 (table name in MySQL)\n\tresult = db.get_engine(current_app, modality+'_data').execute(\"SELECT gene_id FROM genes WHERE gene_id LIKE %s\", (gene+\"%\",)).fetchone()\n\tgene_table_name = 'gene_' + result['gene_id'].replace('.','_')\n\n\tif smoothing and (modalityu=='ATAC'):\n\t\tcounts_type='smoothed_normalized_counts'\n\telse:\n\t\tcounts_type='normalized_counts'\n\n\tquery = \"SELECT cells.cell_id, cells.cell_name, cells.dataset, \\\n\t\t%(ensemble)s.annotation_%(modality)s, %(ensemble)s.cluster_%(modality)s, \\\n\t\t%(ensemble)s.tsne_x_%(modality)s, %(ensemble)s.tsne_y_%(modality)s, \\\n\t\t%(gene_table_name)s.%(counts_type)s as normalized_counts, \\\n\t\tdatasets.target_region \\\n\t\tFROM cells \\\n\t\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\n\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\n\t\tLEFT JOIN datasets ON cells.dataset = datasets.dataset\" % {'ensemble': ensemble,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'gene_table_name': gene_table_name,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'counts_type': counts_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'modality': modalityu}\n\n\tif max_points.isdigit():\n\t\tquery = query+\" ORDER BY RAND() LIMIT %(max_points)s\" % {'max_points': max_points}\n\n\ttry:\n\t\tdf = pd.read_sql(query, db.get_engine(current_app, '%s_data' % modality))\n\texcept exc.ProgrammingError as e:\n\t\tnow = datetime.datetime.now()\n\t\tprint(\"[{}] ERROR in app(get_gene_snATAC): {}\".format(str(now), e))\n\t\tsys.stdout.flush()\n\t\treturn None\n\n\tif df.empty: # If no data in column, return None\n\t\tnow = datetime.datetime.now()\n\t\tprint(\"[{}] ERROR in app(get_gene_snATAC): No snATAC data for {}\".format(str(now), ensemble))\n\t\tsys.stdout.flush()\n\t\treturn None\n\n\tif grouping == 'annotation':\n\t\tdf.fillna({'annotation_%s' % modality: 'None'}, inplace=True)\n\t\tdf['annotation_cat'] = pd.Categorical(df['annotation_%s' % modality], cluster_annotation_order)\n\t\tdf.sort_values(by='annotation_cat', inplace=True)\n\t\tdf.drop('annotation_cat', axis=1, inplace=True)\n\telif grouping == 'cluster':\n\t\tdf.sort_values(by='cluster_%s' % modality, inplace=True)\n\n\tdf['normalized_counts'].fillna(0, inplace=True)\n\n\treturn df","def get_data(self):","def get_gaia_data(ra, dec, search_radius=10.):\n # Get the positions of the Gaia sources\n c1 = SkyCoord(ra, dec, frame='icrs', unit='deg')\n # We are querying with a diameter as the radius, overfilling by 2x.\n from astroquery.vizier import Vizier\n Vizier.ROW_LIMIT = -1\n if args.DR2:\n gaia_cat, catID = \"I/345/gaia2\", \"DR2\"\n print('\\t --> Using Gaia DR2 as requested by user...')\n else:\n gaia_cat, catID = \"I/355/gaiadr3\", \"DR3\"\n\n result = Vizier.query_region(c1, catalog=[gaia_cat],\n radius=Angle(search_radius, \"arcsec\"))\n try:\n \tresult = result[gaia_cat]\n except:\n print('Not in Gaia '+catID+'. If you know the Gaia ID and Gmag, try the options --gid and --gmag.')\n print('Exiting without finishing...')\n sys.exit()\n\n no_targets_found_message = ValueError('Either no sources were found in the query region '\n 'or Vizier is unavailable')\n too_few_found_message = ValueError('No sources found closer than 1 arcsec to TPF coordinates')\n if result is None:\n raise no_targets_found_message\n elif len(result) == 0:\n raise too_few_found_message\n\n if len(result)>1:\n dist = np.sqrt((result['RA_ICRS']-ra)**2 + (result['DE_ICRS']-dec)**2)\n idx = np.where(dist == np.min(dist))[0][0]\n return result[idx]['Source'], result[idx]['Gmag']\n else:\n return result[0]['Source'], result[0]['Gmag']","async def test_get_ac_from_gene(test_db):\n resp = await test_db.get_ac_from_gene(\"BRAF\")\n assert resp == [\"NC_000007.14\", \"NC_000007.13\"]\n\n resp = await test_db.get_ac_from_gene(\"HRAS\")\n assert resp == [\"NC_000011.10\", \"NC_000011.9\"]\n\n resp = await test_db.get_ac_from_gene(\"dummy\")\n assert resp == []","def get_gene_RNA(ensemble, gene, grouping, outliers, max_points='10000', smoothing=False, modality='RNA'):\n\n\t# Prevent SQL injected since column names cannot be parameterized.\n\tif \";\" in ensemble or \";\" in grouping:\n\t\treturn None\n\n\t# This query is just to fix gene id's missing the ensemble version number.\n\t# Necessary because the table name must match exactly with whats on the MySQL database.\n\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3 -> gene_ENSMUSG00000026787_3 (table name in MySQL)\n\tresult = db.get_engine(current_app, 'RNA_data').execute(\"SELECT gene_id FROM genes WHERE gene_id LIKE %s\", (gene+\"%\",)).fetchone()\n\tgene_table_name = 'gene_' + result['gene_id'].replace('.','_')\n\n\tquery = \"SELECT cells.cell_id, cells.cell_name, cells.dataset, \\\n\t\t%(ensemble)s.annotation_RNA, %(ensemble)s.cluster_RNA, \\\n\t\t%(ensemble)s.tsne_x_RNA, %(ensemble)s.tsne_y_RNA, \\\n\t\t%(gene_table_name)s.normalized_counts, \\\n\t\tdatasets.target_region \\\n\t\tFROM cells \\\n\t\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\n\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\n\t\tLEFT JOIN datasets ON cells.dataset = datasets.dataset\" % {'ensemble': ensemble,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'gene_table_name': gene_table_name}\n\tif max_points.isdigit():\n\t\tquery = query+\" ORDER BY RAND() LIMIT %(max_points)s\" % {'max_points': max_points}\n\n\ttry:\n\t\tdf = pd.read_sql(query, db.get_engine(current_app, 'RNA_data'))\n\texcept exc.ProgrammingError as e:\n\t\tnow = datetime.datetime.now()\n\t\tprint(\"[{}] ERROR in app(get_gene_RNA): {}\".format(str(now), e))\n\t\tsys.stdout.flush()\n\t\treturn None\n\n\tif df.empty: # If no data in column, return None\n\t\tnow = datetime.datetime.now()\n\t\tprint(\"[{}] ERROR in app(get_gene_RNA): No RNA data for {}\".format(str(now), ensemble))\n\t\tsys.stdout.flush()\n\t\treturn None\n\n\tif grouping == 'annotation':\n\t\tdf.fillna({'annotation_RNA': 'None'}, inplace=True)\n\t\tdf['annotation_cat'] = pd.Categorical(df['annotation_RNA'], cluster_annotation_order)\n\t\tdf.sort_values(by='annotation_cat', inplace=True)\n\t\tdf.drop('annotation_cat', axis=1, inplace=True)\n\telif grouping == 'cluster':\n\t\tdf.sort_values(by='cluster_RNA', inplace=True)\n\n\tdf['normalized_counts'].fillna(0, inplace=True)\n\n\treturn df","def gene(self):\n\t\tif self._record is None:\n\t\t\treturn []\n\t\tgene_list =[i for i in self._record.features if i.type == 'gene']\n\t\treturn gene_list","def get_gene_from_mysql(ensemble, gene_table_name, methylation_type, clustering, tsne_type, grouping='cluster', max_points='10000'):\n\n\tcontext = methylation_type[1:]\n\tif grouping in ['annotation','cluster']:\n\t\tgroupingu = ensemble+\".\"+grouping+\"_\"+clustering\n\telif grouping in ['NeuN']:\n\t\tgroupingu = \"CONCAT('NeuN',cells.\"+grouping+\")\"\n\telif grouping in ['dataset','sex','brain_region','target_region']:\n\t\tgroupingu = \"datasets.\"+grouping\n\telif grouping in ['broad_brain_region']:\n\t\tgroupingu = \"ABA_regions.ABA_broad_acronym\"\n\telse:\n\t\tgroupingu = \"cells.\"+grouping\n\n\n\tt0=datetime.datetime.now()\n\t# print(' Running get_gene_from_mysql for '+gene_table_name+' : '+str(t0)+'; ', file=open(log_file,'a'))# EAM - Profiling SQL\n\tif tsne_type=='noTSNE':\n\t\tquery = \"SELECT %(gene_table_name)s.%(methylation_type)s, %(gene_table_name)s.%(context)s \\\n\t\t\tFROM %(ensemble)s \\\n\t\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id\" % {'ensemble': ensemble,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'gene_table_name': gene_table_name,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'methylation_type': methylation_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'context': context,}\n\telif 'ndim2' in tsne_type:\n\t\tquery = \"SELECT cells.cell_id, cells.dataset, %(ensemble)s.cluster_%(clustering)s, datasets.target_region, \\\n\t\t\t%(ensemble)s.annotation_%(clustering)s, %(gene_table_name)s.%(methylation_type)s, \\\n\t\t\tcells.global_%(methylation_type)s, %(groupingu)s as grouping, \\\n\t\t\t%(ensemble)s.tsne_x_%(tsne_type)s, %(ensemble)s.tsne_y_%(tsne_type)s, \\\n\t\t\t%(gene_table_name)s.%(context)s, datasets.sex \\\n\t\t\tFROM cells \\\n\t\t\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\n\t\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\n\t\t\tLEFT JOIN datasets ON cells.dataset = datasets.dataset \\\n\t\t\tLEFT JOIN ABA_regions ON datasets.brain_region=ABA_regions.ABA_acronym \" % {'ensemble': ensemble, 'groupingu': groupingu,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'gene_table_name': gene_table_name,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'tsne_type': tsne_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'methylation_type': methylation_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'context': context,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'clustering': clustering,}\n\telse: # 3D tSNE\n\t\tquery = \"SELECT cells.cell_id, cells.cell_name, cells.dataset, cells.global_%(methylation_type)s, \\\n\t\t\t%(ensemble)s.annotation_%(clustering)s, %(ensemble)s.cluster_%(clustering)s, \\\n\t\t\t%(ensemble)s.tsne_x_%(tsne_type)s, %(ensemble)s.tsne_y_%(tsne_type)s, %(ensemble)s.tsne_z_%(tsne_type)s, \\\n\t\t\t%(gene_table_name)s.%(methylation_type)s, %(gene_table_name)s.%(context)s, \\\n\t\t\tdatasets.target_region, datasets.sex \\\n\t\t\tFROM cells \\\n\t\t\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\n\t\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \" % {'ensemble': ensemble,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'gene_table_name': gene_table_name,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'tsne_type': tsne_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'methylation_type': methylation_type,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'context': context,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'clustering': clustering,}\n\tif max_points.isdigit():\n\t\tquery = query+\" ORDER BY RAND() LIMIT %(max_points)s\" % {'max_points': max_points}\n\n\ttry:\n\t\tdf = pd.read_sql(query, db.get_engine(current_app, 'methylation_data'))\n\texcept exc.ProgrammingError as e:\n\t\tnow = datetime.datetime.now()\n\t\tprint(\"[{}] ERROR in app(get_mult_gene_methylation): {}\".format(str(now), e))\n\t\tsys.stdout.flush()\n\t\treturn None\n\n\treturn df","def get_gene(identifier):\n for store in [GENES, ALIASES]:\n genes = store.get(identifier, None)\n if genes and len(genes) == 1:\n return genes\n else:\n raise ValueError('gene reference does not exist or refers to multiple genes')","def _gene_ann(gene_ann_path):\n gene_ann = pd.read_csv(gene_ann_path)\n protein_gene = gene_ann[gene_ann.gene_type ==\n 'protein_coding'].gene_name.tolist()\n return(protein_gene)","async def test_get_genomic_tx_data(test_db, genomic_tx_data):\n resp = await test_db.get_genomic_tx_data(\"NM_004333.4\", (2145, 2145))\n assert resp == {\n \"gene\": \"BRAF\",\n \"strand\": \"-\",\n \"tx_pos_range\": (2053, 2188),\n \"alt_pos_range\": (140739811, 140739946),\n \"alt_aln_method\": \"splign\",\n \"tx_exon_id\": 780496,\n \"alt_exon_id\": 6619852,\n \"tx_ac\": \"NM_004333.4\",\n \"alt_ac\": \"NC_000007.14\",\n \"pos_change\": (92, 43),\n \"alt_pos_change_range\": (140739854, 140739854)\n }","def _get_gedi2a_main_data_dict(self) -> dict:\n gedi_l2a_count_start = pd.to_datetime(\"2018-01-01T00:00:00Z\")\n data = {\n # General identifiable data\n \"granule_name\": [self.parent_granule.filename] * self.n_shots,\n \"shot_number\": self[\"shot_number\"][:],\n \"beam_type\": [self.beam_type] * self.n_shots,\n \"beam_name\": [self.name] * self.n_shots,\n # Temporal data\n \"delta_time\": self[\"delta_time\"][:],\n \"absolute_time\": (\n gedi_l2a_count_start\n + pd.to_timedelta(list(self[\"delta_time\"]), unit=\"seconds\")\n ),\n # Quality data\n \"sensitivity\": self[\"sensitivity\"][:],\n \"quality_flag\": self[\"quality_flag\"][:],\n \"solar_elevation\": self[\"solar_elevation\"][:],\n \"solar_azimuth\": self[\"solar_elevation\"][:],\n \"energy_total\": self[\"energy_total\"][:],\n # DEM\n \"dem_tandemx\": self[\"digital_elevation_model\"][:],\n \"dem_srtm\": self[\"digital_elevation_model_srtm\"][:],\n # Processing data\n \"selected_algorithm\": self[\"selected_algorithm\"][:],\n \"selected_mode\": self[\"selected_mode\"][:],\n # Geolocation data\n \"lon_lowestmode\": self[\"lon_lowestmode\"][:],\n \"longitude_bin0_error\": self[\"longitude_bin0_error\"][:],\n \"lat_lowestmode\": self[\"lat_lowestmode\"][:],\n \"latitude_bin0_error\": self[\"latitude_bin0_error\"][:],\n \"elev_lowestmode\": self[\"elev_lowestmode\"][:],\n \"elevation_bin0_error\": self[\"elevation_bin0_error\"][:],\n \"lon_highestreturn\": self[\"lon_highestreturn\"][:],\n \"lat_highestreturn\": self[\"lat_highestreturn\"][:],\n \"elev_highestreturn\": self[\"elev_highestreturn\"][:],\n } | {f\"rh{i}\": self[\"rh\"][:, i] for i in range(101)}\n return data","def readOneData(self):\n\t\tpass","def get_gene(self, gene_id, source=\"eid\"):\n\n gene_id = str(gene_id)\n\n \n try:\n valid_gene = self.gene_cache[self.source_cache[source][gene_id]]\n return valid_gene\n except KeyError:\n pass\n \n valid_eid = None\n\n if source == \"eid\":\n try:\n eid = int(gene_id)\n except ValueError:\n raise ValueError(\"gene_id must be an integer if source \" + \\\n \"is \\\"Entrez\\\"\")\n\n self.cursor.execute(\"\"\"\n SELECT EXISTS(\n SELECT * \n FROM genes \n WHERE entrez_id = %(eid)s\n )\"\"\", {'eid': eid})\n if self.cursor.fetchone()[0] == 1:\n valid_eid = eid\n\n else:\n\n self.cursor.execute(\"\"\"\n SELECT entrez_id\n FROM discontinued_genes\n WHERE discontinued_id = %(eid)s\"\"\", {'eid': eid})\n row = self.cursor.fetchone()\n if row is not None:\n valid_eid = row[0]\n else:\n raise KeyError(\"Entrez ID %d was not found in the database\" % eid)\n\n elif source == \"symbol\":\n\n args = {\"symbol\": gene_id}\n self.cursor.execute(\"\"\"\n SELECT entrez_id\n FROM genes\n WHERE symbol = %(symbol)s\"\"\", args)\n row = self.cursor.fetchone()\n if row is not None:\n valid_eid = row[0]\n else:\n self.cursor.execute(\"\"\"\n SELECT entrez_id\n FROM discontinued_genes\n WHERE discontinued_symbol = %(symbol)s\"\"\", args)\n row = self.cursor.fetchone()\n if row is not None:\n valid_eid = row[0]\n else:\n self.cursor.execute(\"\"\"\n SELECT entrez_id\n FROM gene_synonyms\n WHERE symbol = %(symbol)s\"\"\", args)\n row = self.cursor.fetchone()\n if row is not None:\n valid_eid = row[0]\n else:\n raise KeyError(\"Symbol %s not found in the database\" % gene_id)\n else:\n self.cursor.execute(\"\"\"\n SELECT entrez_id\n FROM gene_xrefs\n WHERE Xref_db = %(db)s\n AND Xref_id = %(id)s\"\"\", {'db': source, 'id': gene_id})\n row = self.cursor.fetchone()\n if row is not None:\n valid_eid = row[0]\n else:\n raise KeyError((\"Gene ID %s from source %s was not found \" + \\\n \"in the database\") % (gene_id, source))\n\n if valid_eid is None:\n raise KeyError(\"Unable to find a valid Entrez ID for %s from %s\" % (gene_id, source))\n\n valid_eid = int(valid_eid)\n if source not in self.source_cache:\n self.source_cache[source] = {}\n self.source_cache[source][gene_id] = valid_eid\n self.gene_cache[valid_eid] = Gene(valid_eid, self)\n\n return self.gene_cache[valid_eid]","def get_gene_ids():\n key = ('materialized', 'hugo')\n if data.exists(*key):\n return data.load(*key)\n d = hugo.get_huge_genes()\n d = d[~d['Approved Name'].str.lower().str.contains('symbol withdrawn|entry withdrawn')]\n d = d['Approved Symbol'].unique()\n data.save(*key, d)\n return d","def test_gxd_simple(self):\n \n gxd = get_gxd(gxd_file, self.emapa, (0.5, 0.05)) \n \n # check ids\n self.assertEqual(len(gxd), 3, \"three models/markers\")\n self.assertEqual(gxd[\"MA:010\"].id, \"GXD_MA:010\")\n self.assertEqual(gxd[\"MA:011\"].id, \"GXD_MA:011\")\n self.assertEqual(gxd[\"MA:009\"].id, \"GXD_MA:009\")\n \n # check markers\n self.assertEqual(gxd[\"MA:010\"].description[\"marker_id\"], \"MA:010\")\n self.assertEqual(gxd[\"MA:011\"].description[\"marker_id\"], \"MA:011\")\n self.assertEqual(gxd[\"MA:009\"].description[\"marker_id\"], \"MA:009\")\n \n # check parsing and consensus for phenotype \n self.assertEqual(len(gxd[\"MA:010\"].data), 1, \"1+\")\n self.assertEqual(len(gxd[\"MA:011\"].data), 2, \"1+, 1- phenotypes\")\n self.assertEqual(len(gxd[\"MA:009\"].data), 1, \"1+ after consensus\")\n \n # MA:009 should be averaged over assay, weighted by strength\n # i.e. value 1, tpr_raw*(2/3)\n datum = gxd[\"MA:009\"].data[0]\n self.assertEqual(datum.value, 1, \"overall should be detected\") \n self.assertEqual(datum.tpr, (0.05 + (0.5-0.05)*0.25)*2/3)\n self.assertEqual(datum.fpr, 0.05)\n \n # MA:010 should be average (Strong, Not specified), weighted by strength only\n datum = gxd[\"MA:010\"].data[0]\n self.assertEqual(datum.value, 1, \"overall is detected\")\n self.assertEqual(datum.tpr, 0.05 + (0.5-0.05)*0.75)\n self.assertEqual(datum.fpr, 0.05)","def load_gene_data_from_file(self) -> None:\n logger.info(\"Loading genes data from file\")\n if not self.gene_data or len(self.gene_data.items()) == 0:\n self.gene_data = {}\n file_path = self._get_cached_file(cache_path=self.gene_data_cache_path, file_source_url=self.gene_data_url)\n with open(file_path) as file:\n for line in file:\n fields = line.strip().split(',')\n if fields[1].startswith(\"WBGene\"):\n name = fields[2] if fields[2] != '' else fields[3]\n self.gene_data[\"WB:\" + fields[1]] = Gene(\"WB:\" + fields[1], name, fields[4] == \"Dead\", False)","def get_data():\n pass","def get_data():\n pass","def get_data():\n pass","def next_gene(self):\n pass","def tcga_read_data():\n print(\"Downloading data ...\")\n try:\n os.mkdir(cache_directory)\n except FileExistsError:\n pass\n \n brca_path= os.path.join(cache_directory, expression_matrix_name + \".tsv.gz\")\n brca_clin_path = os.path.join(cache_directory, phenotype_name + \".tsv.gz\")\n try:\n brca = pd.read_csv(brca_path, sep=\"\\t\",index_col=0)\n brca_clin = pd.read_csv(brca_clin_path, sep=\"\\t\",index_col=0)\n return brca, brca_clin\n except:\n pass\n\n # Download TCGA data\n tcga_path = os.path.join(cache_directory, tcga_name + \".tar.gz\")\n download_file_if_not_present(tcga_url, tcga_path)\n print(\"Tar-file inplace, extracting tables.\")\n\n # Decompress data into tables\n tf = tarfile.open(tcga_path)\n tf.extract(expression_name, cache_directory)\n tf.extract(clinical_name, cache_directory)\n\n # def get_expression_data(self, path, file):\n df = pd.read_csv(os.path.join(cache_directory, expression_name), sep=\"\\t\")\n df.dropna(axis=0, how='any', inplace=True)\n df.set_index('Entrez_Gene_Id', inplace=True)\n # df.drop(columns=['Unnamed: 0', 'Entrez_Gene_Id'], inplace=True)\n # df.drop(columns=['Entrez_Gene_Id'], inplace=True)\n df.drop(columns=['Hugo_Symbol'], inplace=True)\n brca = df.reindex(sorted(df.columns), axis=1)\n\n # get_clinical_data(brca_clin_path,\"data_clinical_sample.txt\")\n df = pd.read_csv(os.path.join(cache_directory, clinical_name), sep=\"\\t\").T\n df.columns = df.loc[\"Sample Identifier\"]\n df.drop(columns=[\"A unique sample identifier.\",\"STRING\",\"1\",\"SAMPLE_ID\"], inplace=True,errors='ignore')\n if 'TCGA-BH-A1ES-01' in df.columns:\n df.drop(columns=['TCGA-BH-A1ES-01'], inplace=True)\n df.drop(index=[\"Unnamed: 0\",\"#Patient Identifier\",\"Sample Identifier\",\"Other Sample ID\"], inplace=True,errors='ignore')\n brca_clin = df.reindex(sorted(df.columns), axis=1)\n\n brca_clin, brca_clin = tcga_tn_preprocess(brca, brca_clin)\n\n # Put the extracted matrixes to the file cashe, so we do not have to do this again if procedure is repeated.\n brca.to_csv(brca_path, sep=\"\\t\")\n brca_clin.to_csv(brca_clin_path, sep=\"\\t\")\n return brca, brca_clin","def test_get_genome_8(self):\n self.tkt1.data_add = set([\"accession\"])\n gnm = tickets.get_genome(self.tkt1, gnm_type=\"add\")\n with self.subTest():\n self.assertEqual(gnm.host_genus, \"\")\n with self.subTest():\n self.assertEqual(gnm.accession, \"ABC123\")","def sample_meta(self):\n return self._data.iloc[:, self.n_genes :]","def get_aggregation_popensity_df():\n df = pandas.read_csv(fixpath('DnaK_reactions_parameters_5.csv'))\n\n return df.set_index('gene')","def get_data():\n if not hasattr(g, 'data'):\n g.data = load_data()\n return g.data","def test_get_g_data_1(self):\n self.db_filter.values = [40481]\n\n g_data = review.get_g_data(self.alchemist, self.db_filter, 40481)\n\n self.assertTrue(isinstance(g_data, list))\n\n for header in review.PG_HEADER:\n with self.subTest(header=header):\n self.assertTrue(header in g_data[0].keys())\n self.assertFalse(isinstance(g_data[0][header], list))","def retrieve_genome_data(filepath):\n try:\n seqrecords = list(SeqIO.parse(filepath, \"genbank\"))\n except:\n seqrecords = []\n # filename = filepath.split(\"/\")[-1]\n if len(seqrecords) == 0:\n print(f\"There are no records in {filepath.name}.\")\n seqrecord = None\n elif len(seqrecords) > 1:\n print(f\"There are multiple records in {filepath.name}.\" )\n seqrecord = None\n else:\n seqrecord = seqrecords[0]\n return seqrecord","def test_get_genome_1(self):\n self.tkt1.data_add = set([\"\"])\n gnm = tickets.get_genome(self.tkt1, gnm_type=\"add\")\n with self.subTest():\n self.assertEqual(gnm.id, \"Trixie\")\n with self.subTest():\n self.assertEqual(gnm.name, \"Trixie_Draft\")\n with self.subTest():\n self.assertEqual(gnm.type, \"add\")\n with self.subTest():\n self.assertEqual(gnm.host_genus, \"\")\n with self.subTest():\n self.assertEqual(gnm.cluster, \"\")\n with self.subTest():\n self.assertEqual(gnm.subcluster, \"\")\n with self.subTest():\n self.assertEqual(gnm.annotation_status, \"\")\n with self.subTest():\n self.assertEqual(gnm.annotation_author, -1)\n with self.subTest():\n self.assertEqual(gnm.retrieve_record, -1)\n with self.subTest():\n self.assertEqual(gnm.accession, \"\")","def data_from_result():\n return dict(\n gene=\"BRAF\",\n strand=\"-\",\n tx_pos_range=(1802, 1921),\n alt_pos_range=(140453074, 140453193),\n alt_aln_method=\"splign\",\n tx_exon_id=780494,\n alt_exon_id=1927263\n )","def GetGeneName(arg):\n\n genbank = ChromUnzip(arg)\n \n p1=re.compile(r'(?:ACCESSION\\s+)(\\w+\\d+)')\n p6=re.compile(r'(?:/gene=\")(.+?)(?:\"\\s+)')\n\n gene_name_dict={}\n \n for entry in genbank:\n gene_list=[] \n gene_it_6=p6.finditer(entry)\n gene_it_1=p1.finditer(entry) \n for hit in gene_it_6:\n gene_list.append(hit.group(1))\n for item in gene_it_1:\n gene_name_dict[item.group(1)]=gene_list[0]\n \n return gene_name_dict","def generate_gene_set_data(\n data,\n genes,\n gene_name_type=\"entrez\",\n gene_set_category=\"c6.all\",\n metric=\"mean\",\n standardize=False,\n data_dir=\"../../Data/examples/Gene_Sets/MSigDB.v7.0/\",\n):\n\n sample_name = None\n if isinstance(data, pd.DataFrame):\n sample_name = data.index\n data = data.values\n elif not isinstance(data, np.ndarray):\n print(\"Input data must be a numpy array or pandas data frame\")\n sys.exit(1)\n\n if standardize:\n scaler = StandardScaler()\n data = scaler.fit_transform(data)\n\n genes = [str(i) for i in genes]\n\n if gene_name_type == \"entrez\":\n gene_set_category = gene_set_category + \".v7.0.entrez.gmt\"\n if gene_name_type == \"symbols\":\n gene_set_category = gene_set_category + \".v7.0.symbols.gmt\"\n f = open(data_dir + gene_set_category, \"r\")\n x = f.readlines()\n gene_sets = {}\n for i in range(len(x)):\n temp = x[i].split(\"\\n\")[0].split(\"\\t\")\n gene_sets[temp[0]] = temp[2:]\n\n gene_set_data = np.empty((data.shape[0], len(gene_sets)))\n gene_set_data.fill(np.nan)\n gene_set_names = np.array(list(gene_sets.keys()))\n for i in range(len(gene_set_names)):\n idi = np.where(np.isin(genes, gene_sets[gene_set_names[i]]))[0]\n if len(idi) > 0:\n if metric == \"sum\":\n gene_set_data[:, i] = np.nansum(data[:, idi], axis=1)\n elif metric == \"max\":\n gene_set_data[:, i] = np.nanmax(data[:, idi], axis=1)\n elif metric == \"min\":\n gene_set_data[:, i] = np.nanmin(data[:, idi], axis=1)\n elif metric == \"abs_mean\":\n gene_set_data[:, i] = np.nanmean(np.absolute(data[:, idi]), axis=1)\n elif metric == \"abs_maximum\":\n gene_set_data[:, i] = np.nanmax(np.absolute(data[:, idi]), axis=1)\n else: # 'mean'\n gene_set_data[:, i] = np.nanmean(data[:, idi], axis=1)\n\n if sample_name is None:\n gene_set_data = pd.DataFrame(gene_set_data, columns=gene_set_names)\n else:\n gene_set_data = pd.DataFrame(\n gene_set_data, columns=gene_set_names, index=sample_name\n )\n keep_id = np.where(np.sum(np.invert(pd.isna(gene_set_data)), axis=0) > 0)[0]\n gene_set_data = gene_set_data.iloc[:, keep_id]\n\n return gene_set_data","def get_gga_data(port):\n \n \n # Wait for GGA message :\n gga = port.readline().decode(\"utf-8\")\n while not 'GGA' in gga:\n if gga: print(\"Wait for GGA : \", gga)\n gga = port.readline().decode(\"utf-8\")\n \n \n t = np.float(gga[7:16])\n \n # Print messages :\n print(\"Heading antenna frame :\")\n print(\" GGA: \",gga)\n \n # Quality check :\n if not 'GGA' in gga:\n print(\"Issue with GGA frame decoding !\\nMessage:\\nGGA:{0}\\n\".format(gga))\n gga, t = get_gga_data(port)\n \n return gga, t","def get_genes(request, genome, chrom, start, end):\n logger.debug(\"annotation_server.get_genes called for genome: %s chromosome: %s\" % (genome, chrom)) \n \n if genome in SUPPORTED_GENOMES:\n current_table = eval(genome+ \"_EnsGene\")\n curr_vals = current_table.objects.filter(\n Q(chrom__iexact=chrom),\n Q(cdsStart__range=(start, end)) | Q(cdsEnd__range=(start, end))\n ).values('name', 'chrom', 'strand', 'txStart', 'txEnd', 'cdsStart', 'cdsEnd', 'exonCount', 'exonStarts', 'exonEnds')\n data = ValuesQuerySetToDict(curr_vals)\n return HttpResponse(data, 'application/json')\n else:\n return HttpResponse(status=400)\n \n \n # Postbio query\n #cursor = connection.cursor() \n #query = \"\"\"SELECT x.symbol, r.name, #<r.region as start, #>r.region as end, case when r.same_orient then '+' else '-' end as strand, #<r.cds as cds_start, #>r.cds as cds_end from dm3.flybase r join dm3.flyBase2004Xref x on r.name = x.name JOIN (select id, name from dm3.sequence where name = '%s') n ON n.id = r.seq_id and region && int_interval '(%s,%s)' order by region\"\"\" % (chrom, start, end)\n #cursor.execute(query) \n #return HttpResponse(cursor_to_json(cursor), 'application/javascript')","def data_estagio(self):\n return self._data_estagio","def get_data(self):\n pass","def get_data(self):\n pass","def extract_data( file_name):\n\n main_file = fits.open( file_name)\n\n ssp = main_file[1].data\n flux_elines = main_file[3].data\n org_hdr = main_file[0].header\n\n main_file.close()\n\n ###########################################################################\n # NOTE: The visual band fluxes are multiplied by 10^-16 as stated in the\n # units of the MaNGA Data Model.\n #\n # <https://data.sdss.org/datamodel/files/MANGA_PIPE3D/MANGADRP_VER\n # /PIPE3D_VER/PLATE/manga.Pipe3D.cube.html#hdu1>\n ###########################################################################\n v_band = ssp[0] # in units of erg / s / cm^2\n v_band_err = ssp[4] # in units of erg / s / cm^2\n sMass_density = ssp[19] * u.dex( u.M_sun) # in units of log10( Msun / spaxel**2)\n\n Ha_vel = flux_elines[102] # in units of km/s\n Ha_vel_err = flux_elines[330] # in units of km/s\n\n gal_ra = org_hdr['OBJRA']\n gal_dec = org_hdr['OBJDEC']\n\n target_galaxy = True\n MaNGA_galaxy_target = org_hdr['MNGTARG1']\n if MaNGA_galaxy_target == 0:\n target_galaxy = False\n\n data_quality = True\n DRP_3D_quality = org_hdr['DRP3QUAL']\n if DRP_3D_quality > 10000:\n data_quality = False\n\n return target_galaxy, data_quality, Ha_vel, Ha_vel_err, v_band, v_band_err, \\\n sMass_density, gal_ra, gal_dec","def genes():\n data=pd.read_csv(config['stan'], sep=\" \")\n return list(set(data['Gene_id']))","async def test_mane_c_genomic_data(test_db):\n resp = await test_db.get_mane_c_genomic_data(\n \"NM_001374258.1\", None, 140753335, 140753335\n )\n expected = dict(\n gene=\"BRAF\",\n strand=\"-\",\n tx_pos_range=(2087, 2206),\n alt_pos_range=(140753274, 140753393),\n alt_aln_method=\"splign\",\n tx_exon_id=8439617,\n alt_exon_id=9353476,\n coding_start_site=226,\n coding_end_site=2650,\n alt_pos_change=(57, 62),\n alt_pos_change_range=(140753336, 140753336),\n tx_ac=\"NM_001374258.1\",\n alt_ac=\"NC_000007.14\"\n )\n assert resp == expected","def gatherData(data,neat,gen,iter_i,hyp,savePop=False):\n data.gatherData(neat.pop, neat.species)\n\n if savePop is True: # Get a sample pop to play with in notebooks\n global fileName\n pref = output_dir + '/iter_{}'.format(iter_i) + '/gen_' + str(gen).zfill(4)\n import pickle\n with open(pref+'.obj', 'wb') as fp:\n pickle.dump(neat.pop,fp)\n\n return data","def LoadEEGData(filename, EEGdevice):\n if EEGdevice == 7:\n x = 1\n elif EEGdevice == 8:\n # Read in the .easy file\n df = pd.read_csv(filename, delimiter='\\t', header=None)\n\n # Get metadata from the .info file\n fname = filename[:-5] + '.info'\n with open(fname) as f:\n content = f.readlines()\n content = [x.strip() for x in content]\n\n # Get the channel names\n channel_info = [x for x in content if 'Channel ' in x]\n channel_names = []\n for ch in range(len(channel_info)):\n channel_names.append(channel_info[ch].split(': ')[1])\n\n channel_names.append('X')\n channel_names.append('Y')\n channel_names.append('Z')\n channel_names.append('STI 014')\n channel_names.append('DateTime')\n\n # Get sampling rates\n sampling_rates = [x for x in content if 'sampling rate: ' in x]\n fs_all = []\n for freq in range(len(sampling_rates)):\n tmp = sampling_rates[freq].split(': ')[1].split(' ')[0]\n if tmp in ['N/A']:\n print('Skipping N/A')\n else:\n fs_all.append(float(sampling_rates[freq].split(': ')[1].split(' ')[0]))\n\n # Store sampling rates\n fs = fs_all[0]\n fs_accel = fs_all[1]\n\n # Assign the column names\n df.columns = channel_names\n \n # Return dataframe and sampling rates\n return df, fs, fs_accel","def load_data_gse68465(verbose=-1, read_as_ndarray=False):\n clinical, genes, outcome = load_data_gse('GSE68465', processing_gse68465, verbose, read_as_ndarray)\n\n return clinical, genes, outcome","def extract_gene_args(self, line):\n result = {'seq_name': line[0], 'source': line[1], \\\n 'indices': [int(line[3]), int(line[4])], 'strand': line[6]}\n attribs = self.parse_attributes(line[8])\n\n if not attribs:\n return None\n\n result.update(attribs)\n return result","def test_get_genome_6(self):\n self.tkt1.data_add = set([\"annotation_author\"])\n gnm = tickets.get_genome(self.tkt1, gnm_type=\"add\")\n with self.subTest():\n self.assertEqual(gnm.host_genus, \"\")\n with self.subTest():\n self.assertEqual(gnm.annotation_author, 1)","def isgene(s, gene):\n test = s.query(Genes).filter(Genes.name.ilike(gene)).first()\n if test is None:\n gene_list = check_gene_name(gene)\n if len(gene_list) == 0:\n return None\n else:\n for g in gene_list:\n print(g)\n test = s.query(Genes).filter(Genes.name.ilike(str(g))).first()\n if test is not None:\n return test.name\n return None\n else:\n return test.name","def get_data(self):\r\n pass","def read_dataset_v2():\n path = load_config()\n T = feather.read_dataframe(path['data_dir'] / 'T_dat_v2.feather')\n E = feather.read_dataframe(path['data_dir'] / 'E_dat_v2.feather')\n M = feather.read_dataframe(path['data_dir'] / 'Meta_v2.feather')\n data = sio.loadmat(path['data_dir'] / 'highvar_genes_v2.mat', squeeze_me=True)\n return T, E, M, data","def testEnsemblToGeneFile(self):\n\n e2g = EnsemblToGeneFile(self.enstogenefile)\n\n self.assertTrue(e2g)\n\n self.assertTrue(len(e2g.geneids) == 38803)\n self.assertTrue(len(e2g.tranids) == 94647)","def __getitem__(self, key: str) -> float64:\n\n # extract the gene\n geno_id, allele_variant = geno_to_idx(key)\n\n return self._store[geno_id][allele_variant]","def get_mult_gene_RNA(ensemble, genes, grouping, max_points='10000'):\n\n\t# Prevent SQL injected since column names cannot be parameterized.\n\tif \";\" in ensemble or \";\" in grouping:\n\t\treturn None\n\n\tgenes = [gene+\"%\" for gene in genes]\n\n\t# This query is just to fix gene id's missing the ensemble version number.\n\t# Necessary because the table name must match exactly with whats on the MySQL database.\n\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3\n\tfirst_query = \"SELECT gene_id FROM genes WHERE gene_id LIKE %s\" + \" OR gene_id LIKE %s\" * (len(genes)-1)\n\tresult = db.get_engine(current_app, 'methylation_data').execute(first_query, (genes,)).fetchall()\n\n\tgene_table_names = ['gene_' + gene_id[0].replace('.','_') for gene_id in result]\n\n\tdf_all = pd.DataFrame()\n\n\tfirst = True\n\tfor gene_table_name in gene_table_names:\n\t\tquery = \"SELECT cells.cell_id, cells.cell_name, cells.dataset, \\\n\t\t\t%(ensemble)s.annotation_RNA, %(ensemble)s.cluster_RNA, \\\n\t\t\t%(ensemble)s.tsne_x_RNA, %(ensemble)s.tsne_y_RNA, \\\n\t\t\t%(gene_table_name)s.normalized_counts, \\\n\t\t\tdatasets.target_region \\\n\t\t\tFROM cells \\\n\t\t\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\n\t\t\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\n\t\t\tLEFT JOIN datasets ON cells.dataset = datasets.dataset\" % {'ensemble': ensemble,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t 'gene_table_name': gene_table_name}\n\t\tif max_points.isdigit():\n\t\t\tquery = query+\" ORDER BY RAND() LIMIT %(max_points)s()\" % {'max_points': max_points}\n\n\t\ttry:\n\t\t\tdf_all = df_all.append(pd.read_sql(query, db.get_engine(current_app, 'RNA_data')))\n\t\texcept exc.ProgrammingError as e:\n\t\t\tnow = datetime.datetime.now()\n\t\t\tprint(\"[{}] ERROR in app(get_mult_gene_RNA): {}\".format(str(now), e))\n\t\t\tsys.stdout.flush()\n\t\t\treturn None\n\n\t\tif first:\n\t\t\tdf_coords = df_all\n\t\tfirst = False\n\n\tif df_all.empty: # If no data in column, return None\n\t\tnow = datetime.datetime.now()\n\t\tprint(\"[{}] ERROR in app(get_gene_RNA): No RNA data for {}\".format(str(now), ensemble))\n\t\tsys.stdout.flush()\n\t\treturn None\n\n\tdf_all['normalized_counts'].fillna(0, inplace=True)\n\n\tdf_avg_methylation = df_all.groupby(by='cell_id', as_index=False)['normalized_counts'].mean()\n\tdf_coords.update(df_avg_methylation)\n\n\tif grouping == 'annotation':\n\t\tdf_coords.fillna({'annotation_RNA': 'None'}, inplace=True)\n\t\tdf_coords['annotation_cat'] = pd.Categorical(df_coords['annotation_RNA'], cluster_annotation_order)\n\t\tdf_coords.sort_values(by='annotation_cat', inplace=True)\n\t\tdf_coords.drop('annotation_cat', axis=1, inplace=True)\n\telif grouping == 'cluster':\n\t\tdf_coords.sort_values(by='cluster_RNA', inplace=True)\n\treturn df_coords","def get_aa (tRNA):\n\tpass","def gene_search(\n self,\n genes:list=[\"MYL2\"], \n ):\n try: \n assert isinstance(genes, list)\n except AssertionError as e:\n e.args += (\"[genes] argument needs to be type(list)\", )\n raise\n \n\n self.genes = genes\n\n self.requestURL = f\"https://www.ebi.ac.uk/proteins/api/proteins?offset=0&size=100&gene={'%2C%20'.join(genes)}&organism=human\"\n \n r = requests.get(self.requestURL, headers={ \"Accept\" : \"application/json\"})\n \n if not r.ok:\n r.raise_for_status()\n sys.exit()\n\n self.responseBody = r.text\n self.data = json.loads(self.responseBody)\n\n return self.responseBody","def evaluate(self,gene):\n return prng.choice(gene.allele_set)","def adata():\n return AnnData(\n X=np.ones((2, 2)),\n obs=pd.DataFrame(\n {\"obs1\": [0, 1], \"obs2\": [\"a\", \"b\"]}, index=[\"cell1\", \"cell2\"]\n ),\n var=pd.DataFrame(\n {\"gene_symbols\": [\"genesymbol1\", \"genesymbol2\"]}, index=[\"gene1\", \"gene2\"]\n ),\n layers={\"double\": sparse.csr_matrix(np.ones((2, 2)), dtype=int) * 2},\n dtype=int,\n )","def parseGGA(data):\n #print \"GGA received\"\n # print data\n return pack([\"utc\", \"lat\", \"ns\", \"lon\", \"ew\", \"quality\"\n \"numSats\", \"horizontalDilution\", \"altitude\",\n \"altitudeUnits\", \"separation\", \"separationUnits\",\n \"age\", \"reference\"],\n data)","def queryYM( self, geneName, level ):\n result = [] \n \n # Get a new query on the table\n query = service.new_query(\"Gene\")\n query.add_constraint(\"interactions.participant2\", \"Gene\") \n \n query.add_view( \"primaryIdentifier\", \"symbol\", \"secondaryIdentifier\", \"sgdAlias\", \"name\",\n \"organism.shortName\", \"interactions.details.annotationType\",\n \"interactions.details.phenotype\", \"interactions.details.role1\",\n \"interactions.details.experimentType\", \"interactions.participant2.symbol\",\n \"interactions.participant2.secondaryIdentifier\",\n \"interactions.details.experiment.name\",\n \"interactions.details.relationshipType\" )\n \n query.add_constraint(\"organism.shortName\", \"=\", \"S. cerevisiae\", code = \"B\")\n query.add_constraint(\"Gene\", \"LOOKUP\", geneName, code = \"A\")\n \n for row in query.rows():\n data = level, row[\"primaryIdentifier\"], row[\"symbol\"], row[\"secondaryIdentifier\"], row[\"sgdAlias\"], \\\n row[\"name\"], row[\"organism.shortName\"], row[\"interactions.details.annotationType\"], \\\n row[\"interactions.details.phenotype\"], row[\"interactions.details.role1\"], \\\n row[\"interactions.details.experimentType\"], row[\"interactions.participant2.symbol\"], \\\n row[\"interactions.participant2.secondaryIdentifier\"], \\\n row[\"interactions.details.experiment.name\"], row[\"interactions.details.relationshipType\"]\n item = list(data)\n result.append(item) \n \n return result","def getGeneList( self ):\n return self.geneList","def test_get_genome_2(self):\n self.tkt1.data_add = set([\"host_genus\"])\n gnm = tickets.get_genome(self.tkt1, gnm_type=\"add\")\n with self.subTest():\n self.assertEqual(gnm.host_genus, \"Mycobacterium\")\n with self.subTest():\n self.assertEqual(gnm.cluster, \"\")","def _get_all_oshapes(self):\n an_iname = self.node_list[0]\n an_inode = self.builder.nodes[an_iname]\n an_ishape = an_inode.oshapes['loc']\n \n return {'main' : an_ishape,\n 'loc' : an_ishape,\n 'cov' : an_ishape + [an_ishape[-1]]}","def download_data(self) -> None: # coverage: ignore\n\n navaids = []\n c = requests.get(f\"{base_url}/earth_fix.dat\")\n\n for line in c.iter_lines():\n\n line = line.decode(encoding=\"ascii\", errors=\"ignore\").strip()\n\n # Skip empty lines or comments\n if len(line) < 3 or line[0] == \"#\":\n continue\n\n # Start with valid 2 digit latitude -45. or 52.\n if not ((line[0] == \"-\" and line[3] == \".\") or line[2] == \".\"):\n continue\n\n # Data line => Process fields of this record, separated by a comma\n # Example line:\n # 30.580372 -094.384169 FAREL\n fields = line.split()\n navaids.append(\n Navaid(\n fields[2],\n \"FIX\",\n float(fields[0]),\n float(fields[1]),\n None,\n None,\n None,\n None,\n )\n )\n\n c = requests.get(f\"{base_url}/earth_nav.dat\")\n\n for line in c.iter_lines():\n\n line = line.decode(encoding=\"ascii\", errors=\"ignore\").strip()\n\n # Skip empty lines or comments\n if len(line) == 0 or line[0] == \"#\":\n continue\n\n # Data line => Process fields of this record, separated by a comma\n # Example lines:\n # 2 58.61466599 125.42666626 451 522 30 0.0 A Aldan NDB\n # 3 31.26894444 -085.72630556 334 11120 40 -3.0 OZR CAIRNS VOR-DME\n # type lat lon elev freq ? var id desc\n # 0 1 2 3 4 5 6 7 8\n\n fields = line.split()\n\n # Valid line starts with integers\n if not fields[0].isdigit():\n continue # Next line\n\n # Get code for type of navaid\n itype = int(fields[0])\n\n # Type names\n wptypedict = {\n 2: \"NDB\",\n 3: \"VOR\",\n 4: \"ILS\",\n 5: \"LOC\",\n 6: \"GS\",\n 7: \"OM\",\n 8: \"MM\",\n 9: \"IM\",\n 12: \"DME\",\n 13: \"TACAN\",\n }\n\n # Type code never larger than 20\n if itype not in list(wptypedict.keys()):\n continue # Next line\n\n wptype = wptypedict[itype]\n\n # Select types to read\n if wptype not in [\"NDB\", \"VOR\", \"ILS\", \"GS\", \"DME\", \"TACAN\"]:\n continue # Next line\n\n # Find description\n try:\n idesc = line.index(fields[7]) + len(fields[7])\n description: Optional[str] = line[idesc:].strip().upper()\n except Exception:\n description = None\n\n navaids.append(\n Navaid(\n fields[7],\n wptype,\n float(fields[1]),\n float(fields[2]),\n float(fields[3][1:])\n if fields[3].startswith(\"0-\")\n else float(fields[3]),\n float(fields[4])\n if wptype == \"NDB\"\n else float(fields[4]) / 100,\n float(fields[6])\n if wptype in [\"VOR\", \"NDB\", \"ILS\", \"GS\"]\n else None,\n description,\n )\n )\n\n self._data = pd.DataFrame.from_records(\n navaids, columns=NavaidTuple._fields\n )\n\n self._data.to_pickle(self.cache_dir / \"traffic_navaid.pkl\")","def extract_genes(seq_record):\n return [f for f in seq_record.features if f.type == \"gene\"]","def geneactivity(adata,\n gtf_file,\n key_added='gene',\n upstream=5000,\n feature_type='gene',\n annotation='HAVANA',\n layer_name='geneactivity',\n raw=False, \n copy=True):\n ### extracting the genes\n gtf = {}\n with open(gtf_file) as f:\n for line in f:\n if line[0:2] != '##' and '\\t'+feature_type+'\\t' in line and '\\t'+annotation+'\\t' in line:\n line = line.rstrip('\\n').split('\\t')\n if line[6] == '-':\n if line[0] not in gtf.keys():\n gtf[line[0]] = [[int(line[3]), int(line[4])+upstream,line[-1].split(';')[:-1]]]\n else:\n gtf[line[0]].append([int(line[3]), int(line[4])+upstream,line[-1].split(';')[:-1]])\n else:\n if line[0] not in gtf.keys():\n gtf[line[0]] = [[int(line[3])-upstream, int(line[4]),line[-1].split(';')[:-1]]]\n else:\n gtf[line[0]].append([int(line[3])-upstream, int(line[4]),line[-1].split(';')[:-1]])\n\n # extracting the feature coordinates\n if raw==True:\n raw_adata = adata.raw.to_adata()\n else:\n raw_adata = adata.copy()\n raw_adata_features = {}\n feature_index = 0\n for line in raw_adata.var_names.tolist():\n line = line.split('_')\n if line[0] not in raw_adata_features.keys():\n raw_adata_features[line[0]] = [[int(line[1]),int(line[2]), feature_index]]\n else:\n raw_adata_features[line[0]].append([int(line[1]),int(line[2]), feature_index])\n feature_index += 1\n \n ## find the features overlaping the genes. and build the count matrix\n gene_index = []\n gene_activity_X = []\n \n for chrom in gtf.keys():\n if chrom in raw_adata_features.keys():\n #print(chrom)\n chrom_index = 0\n previous_features_index = 0\n for gene in gtf[chrom]:\n gene_values = []\n gene_start = gene[0]\n gene_end = gene[1]\n for feature in raw_adata_features[chrom]:\n feature_index = 0\n if (feature[1]<= gene_start): # the window is before the gene. we need to test the next window.\n continue\n elif (gene_end <= feature[0]): # the window is after the gene. we need totest the next gene.\n break\n else: # the window is overlapping the gene. \n gene_values.append(raw_adata.X[:,feature[2]].todense())\n if gene_values != []:\n gene_activity_X.append(np.sum(gene_values, axis=0))\n gene_index.append(gene[-1])\n \n\n gene_activity_X = np.concatenate(tuple(gene_activity_X), axis=-1)\n\n # get the variable metadata\n gene_name = []\n if feature_type=='transcript':\n for x in gene_index:\n for y in x:\n if 'transcript_name' in y:\n gene_name.append(y.lstrip(' transcript_name \"').rstrip('\"'))\n #gene_name = [x[7].lstrip(' transcript_name \"').rstrip('\"') for x in gene_index]\n elif feature_type=='gene':\n for x in gene_index:\n for y in x:\n if 'gene_name' in y:\n gene_name.append(y.lstrip(' gene_name \"').rstrip('\"'))\n #gene_name = [x[4].lstrip(' gene_name \"').rstrip('\"') for x in gene_index]\n\n metadata_genes = {'gene_id' : [],\n 'transcript_id' : [],\n 'gene_type' : [],\n 'gene_name' : [],\n 'transcript_type' : [],\n 'transcript_name' : [],\n 'protein_id' : []}\n\n for line in gene_index:\n dico_line = {}\n for element in line:\n if ' \"' in element:\n dico_line[element.rstrip('\"').lstrip(\" \").split(' \"')[0]] = element.rstrip('\"').lstrip(\" \").split(' \"')[1]\n \n for key in metadata_genes.keys():\n if key in dico_line.keys():\n metadata_genes[key].append(dico_line[key])\n else:\n metadata_genes[key].append('NA') \n \n dataframe_genes = pd.DataFrame.from_dict(metadata_genes)\n dataframe_genes.index = gene_name\n\n #adata.layers[layer_name] = ad.AnnData(gene_activity_X, var=dataframe_genes, obs=raw_adata.obs)\n gene_adata = ad.AnnData(gene_activity_X, var=dataframe_genes, obs=raw_adata.obs)\n gene_adata.uns = adata.uns.copy()\n gene_adata.obsm = adata.obsm.copy()\n gene_adata.obsp = adata.obsp.copy()\n return(gene_adata)","def get_hilo_data():\n # Get raw JSON data\n magtag.url = get_data_source_url(hilo_only=True)\n\n return magtag.fetch()","def get_data(dataset, **kwargs):\n age_df = load_age_sample_from_mcmc_chains(dataset, **kwargs)\n hr_df = load_hr()\n age_df, hr_df = clean_data(age_df, hr_df)\n snids = age_df.index.unique().tolist()\n return snids, age_df, hr_df","def gain_data_main():\n gainfile = os.path.join(DATA_PATH, \"zen.2457698.40355.xx.gain.calfits\")\n with uvtest.check_warnings(\n UserWarning,\n match=[\n \"telescope_location is not set. Using known values for HERA.\",\n \"antenna_positions are not set or are being overwritten. Using known \"\n \"values for HERA.\",\n ],\n ):\n gain_object = UVCal.from_file(gainfile, use_future_array_shapes=True)\n gain_object.freq_range = None\n\n yield gain_object\n\n del gain_object","def get_data():\r\n spatial_expmat = np.load('/home/anniegao/spatial_magan/data/spatial_pca_with_coords.npz')['arr_0']\r\n spatial_expmat[:,100:] *= 5\r\n rna_expmat = np.load('/home/anniegao/spatial_magan/data/rna_pca_sampled.npz')['arr_0']\r\n spatial_pca_components = np.load('/home/anniegao/spatial_magan/data/spatial_pca_100components.npz')['arr_0']\r\n rna_pca_components = np.load('/home/anniegao/spatial_magan/data/rna_pca_100components.npz')['arr_0']\r\n spatial_cluster_labels = np.load('/home/anniegao/spatial_magan/data/spatial_cluster_3_labels_phate.npz')['arr_0']\r\n rna_cluster_labels = np.load('/home/anniegao/spatial_magan/data/rna_cluster_5_labels_sampled.npz')['arr_0']\r\n return spatial_expmat, rna_expmat, spatial_pca_components, rna_pca_components, spatial_cluster_labels, rna_cluster_labels","def get_expression(data_series, probes_to_genes):\n with open(data_series, 'r') as mtx:\n stage_columns = {'all_stages': {'sample_ids': []}} # will always need an average, other stages are determined by the file\n sample_ids = None\n for line in mtx:\n if line.startswith('!Sample_title'):\n sample_stages = [x.strip().replace('\"','').split(\",\")[0] for x in line.split(\"\\t\")[1:]] # this line is likely dataset specific.\n elif line.startswith('\"ID_REF\"'): # this comes after the sample titles\n sample_ids = [x.strip().replace('\"','') for x in line.split(\"\\t\")[1:]]\n # now have the ids and their stages, convert to dict\n \"\"\"\n if named differently, may need to modify this.\n ultimately, stage_columns should be a dictionary with the following properties:\n - the keys are the stage names. \n - each 'stage' dict should have a key 'sample_ids' that has a list the sample_ids belonging to that stage.\n {\n 'stage1': {\n 'sample_ids': ['sample_id1','sample_id2', ..., 'sample_idn']\n },\n 'stage2': {\n 'sample_ids': ['sample_idn+1', ...]\n },\n ...\n }\n \"\"\"\n for i in range(0, len(sample_stages)):\n if sample_stages[i] not in stage_columns:\n stage_columns[sample_stages[i]] = {'sample_ids': []}\n stage_columns[sample_stages[i]]['sample_ids'].append(sample_ids[i])\n stage_columns['all_stages']['sample_ids'].append(sample_ids[i]) # add every sample to this\n elif sample_ids is not None:\n row = [x.strip().replace('\"','') for x in line.split('\\t')]\n \"\"\"\n here, the stage_columns dictionary is being updated with the expression data for each gene.\n {\n 'stage1': {\n 'sample_ids': ['sample_id1','sample_id2', ..., 'sample_idn'],\n 'genes': { <- **NEW KEY**\n 'entrezID-1': ['sample_id1ExpLevel', 'sample_id2ExpLevel', ..., 'sample_idnExpLevel'],\n 'entrezID-2': ['sample_id1ExpLevel', 'sample_id2ExpLevel', ..., 'sample_idnExpLevel'],\n ... (if PERCENTILE_RANK is True, all in dataset are recorded otherwise, just the genes of interest )\n }\n },\n ...\n }\n \"\"\"\n if row[0] in probes_to_genes:\n # get gene from probe\n entrez_id = probes_to_genes[row[0]]\n # add the average expression for all the samples in a stage for the gene\n for stage, stage_data in stage_columns.items():\n stage_data['genes'] = {} if 'genes' not in stage_data else stage_data['genes'] # initialize\n for sample_id in stage_data['sample_ids']:\n # get the index of the sample_id in the row\n sample_idx = sample_ids.index(sample_id) + 1\n if entrez_id not in stage_data['genes']:\n stage_data['genes'][entrez_id] = [float(row[sample_idx])]\n else:\n stage_data['genes'][entrez_id].append(float(row[sample_idx]))\n\n return stage_columns","def _get_probe():\n probe_ds = tf.data.TFRecordDataset(\n os.path.join(self.root, self.version, self.probe_folder,\n 'imagenet2012-probe.tfrecord-1-of-1'))\n probe_ds = probe_ds.map(\n self.wrapper_map_probe_v2,\n num_parallel_calls=tf.data.experimental.AUTOTUNE)\n\n # For single file, we need to disable auto_shard_policy for multi-workers,\n # e.g. every worker takes the same file\n options = tf.data.Options()\n options.experimental_distribute.auto_shard_policy = (\n tf.data.experimental.AutoShardPolicy.OFF)\n probe_ds = probe_ds.with_options(options)\n\n return probe_ds","def get_data(self, dataset):\n loop_over_dataset(dataset, self.process_event,\n branch_selection=hax.config['basic_branches'] + list(self.extra_branches))\n self.check_cache(force_empty=True)\n if not hasattr(self, 'data'):\n raise RuntimeError(\"Not a single event was extracted from dataset %s!\" % dataset)\n else:\n return self.data","def extract_data():\n logging.info(f'Reading data from {impftermine.agg_export_file_name()}...')\n df_wl = pd.read_csv(impftermine.agg_export_file_name())\n vacc_report_file = os.path.join(credentials.vmdl_path, 'vaccination_report_bs_age_group_long.csv')\n logging.info(f'Reading data from {vacc_report_file}...')\n df_impf = pd.read_csv(vacc_report_file)\n return df_wl, df_impf","def get_ensembles_summary():\n\tregions = request.args.get('region', '').split()\n\tregions = [ region.lower() for region in regions ]\n\t# Remove suffix after \"-\" -- for compatibility with Dong lab iConnectome\n\tregions = [ re.sub(r'-.*','',region) for region in regions ]\n\tregions_tgt = request.args.get('region_tgt', '').split()\n\tregions_tgt = [ region_tgt.lower() for region_tgt in regions_tgt ]\n\t\n\tensemble_list=[]\n\tensemble_list = db.get_engine(current_app, 'methylation_data').execute(\"SELECT * FROM ensembles\").fetchall()\n\n\ttotal_methylation_cell_each_dataset = db.get_engine(current_app, 'methylation_data').execute(\"SELECT dataset, COUNT(*) as `num` FROM cells GROUP BY dataset\").fetchall()\n\ttotal_snATAC_cell_each_dataset = db.get_engine(current_app, 'snATAC_data').execute(\"SELECT dataset, COUNT(*) as `num` FROM cells GROUP BY dataset\").fetchall()\n\ttotal_methylation_cell_each_dataset = pd.DataFrame(total_methylation_cell_each_dataset, columns=['dataset','num']).set_index('dataset')\n\ttotal_snATAC_cell_each_dataset = pd.DataFrame(total_snATAC_cell_each_dataset, columns=['dataset','num']).set_index('dataset')\n\n\tensembles_cell_counts = []\n\tfor ensemble in ensemble_list:\n\t\tdatasets = ensemble['datasets'].split(',')\n\t\tmethylation_cell_counts=total_methylation_cell_each_dataset.filter(datasets,axis=0)['num'].to_dict()\n\t\tsnATAC_cell_counts=total_snATAC_cell_each_dataset.filter(datasets,axis=0)['num'].to_dict()\n\t\tannoj_exists = ensemble_annoj_exists(ensemble['ensemble_id'])\n\t\tensembles_cell_counts.append( {\"id\": ensemble['ensemble_id'],\n\t\t\t\t\t\t\t\t\t \"ensemble\": ensemble['ensemble_name'],\n\t\t\t\t\t\t\t\t\t \"ens_methylation_counts\": methylation_cell_counts,\n\t\t\t\t\t\t\t\t\t \"ens_snATAC_counts\": snATAC_cell_counts,\n\t\t\t\t\t\t\t\t\t \"public_access\": ensemble['public_access'],\n\t\t\t\t\t\t\t\t\t \"description\": ensemble['description'],\n\t\t\t\t\t\t\t\t\t \"annoj_exists\": annoj_exists,\n\t\t\t\t\t\t\t\t\t \"datasets\": datasets\n\t\t\t\t\t\t\t\t\t })\n\n\t# aba_regions = db.get_engine(current_app, 'methylation_data').execute('SELECT * FROM ABA_regions').fetchall()\n\taba_regions = pd.read_sql('SELECT * FROM ABA_regions', db.get_engine(current_app, 'methylation_data'))\n\taba_regions = aba_regions\n\t\n\tensembles_json_list = []\n\tfor ens in ensembles_cell_counts:\n\t\ttotal_methylation_cells = 0\n\t\ttotal_snATAC_cells = 0\n\t\tdatasets_in_ensemble_cell_count = []\n\t\tdatasets_in_ensemble = []\n\t\tsnATAC_datasets_in_ensemble = []\n\t\tens_dict = {}\n\t\tif ens['ens_methylation_counts'] is not None:\n\t\t\tfor dataset, count in ens['ens_methylation_counts'].items():\n\t\t\t\tens_dict[dataset] = str(count)\n\t\t\t\ttotal_methylation_cells += count\n\t\t\t\tdatasets_in_ensemble.append(dataset)\n\t\t\t\tdatasets_in_ensemble_cell_count.append(dataset+\" (\"+str(count)+\" cells)\")\n\t\t\t\t# ens_dict[dataset] = str(count) + '/' + str(total_methylation_cell_each_dataset[dataset])\n\t\tif ens['ens_snATAC_counts'] is not None:\n\t\t\tfor dataset, count in ens['ens_snATAC_counts'].items():\n\t\t\t\ttotal_snATAC_cells += count\n\t\t\t\tdatasets_in_ensemble.append('CEMBA_'+dataset)\n\t\t\t\tsnATAC_datasets_in_ensemble.append(dataset+\" (\"+str(count)+\" cells)\")\n\n\n\t\t# Do not display ensembles that contain less than 200 total cells. (mainly RS2 data)\n\t\tif total_methylation_cells>0 or total_snATAC_cells>0:\n\n\t\t\tens_dict[\"ensemble_id\"] = ens['id']\n\t\t\tens_dict[\"ensemble_name\"] = ens['ensemble']\n\t\t\tens_dict[\"description\"] = ens['description']\n\t\t\tens_dict[\"datasets_rs1\"] = \", \".join(sorted([x for x in datasets_in_ensemble_cell_count if 'RS2' not in x]))\n\t\t\tens_dict[\"datasets_rs2\"] = \", \".join(sorted([x for x in datasets_in_ensemble_cell_count if 'RS2' in x]))\n\t\t\trs2_datasets_in_ensemble = sorted([x for x in datasets_in_ensemble if 'RS2' in x])\n\t\t\tens_dict[\"target_regions_rs2_acronym\"] = \"\"\n\t\t\tens_dict[\"target_regions_rs2_descriptive\"] = \"\"\n\t\t\tens_dict[\"ABA_regions_acronym\"] = ''\n\t\t\tens_dict[\"ABA_regions_description\"] = ''\n\n\t\t\t# TODO: \n\t\t\tif len(rs2_datasets_in_ensemble) != 0:\n\t\t\t\ttarget_regions_query = \"SELECT DISTINCT datasets.target_region, ABA_regions.ABA_description \\\n\t\t\t\t\tFROM datasets \\\n\t\t\t\t\tINNER JOIN ABA_regions ON ABA_regions.ABA_acronym=datasets.target_region \\\n\t\t\t\t\tAND datasets.dataset in (\" + \",\".join((\"%s\",) * len(rs2_datasets_in_ensemble)) + \")\"\n\t\t\t\ttarget_regions_result = db.get_engine(current_app, 'methylation_data').execute(target_regions_query, tuple(rs2_datasets_in_ensemble,)).fetchall()\n\t\t\t\tens_dict[\"target_regions_rs2_acronym\"] = \", \".join([ x.target_region for x in target_regions_result ])\n\t\t\t\tens_dict[\"target_regions_rs2_descriptive\"] = \", \".join([ x.ABA_description for x in target_regions_result ])\n\n\t\t\t\t# target_regions_result = aba_regions.loc[rs2_datasets_in_ensemble,'ABA_description']\n\n\t\t\tens_dict[\"snATAC_datasets_rs1\"] = \", \".join(sorted([x for x in snATAC_datasets_in_ensemble if 'RS2' not in x]))\n\t\t\tens_dict[\"snATAC_datasets_rs2\"] = \", \".join(sorted([x for x in snATAC_datasets_in_ensemble if 'RS2' in x]))\n\t\t\tens_dict[\"num_datasets\"] = len(datasets_in_ensemble_cell_count)+len(snATAC_datasets_in_ensemble)\n\n\t\t\tslices_list_rs1 = re.findall('CEMBA_([0-9]+[A-Z])',','.join(ens['datasets']))\n\t\t\tslices_list_rs2 = re.findall('CEMBA_RS2_[A-Z][mf]([0-9]+[A-Z])',','.join(ens['datasets']))\n\t\t\tslices_set = set(slices_list_rs1)\n\t\t\tslices_set.update(slices_list_rs2)\n\t\t\tens_dict[\"slices\"] = \", \".join(sorted(list(slices_set)))\n\t\t\tens_dict[\"total_methylation_cells\"] = total_methylation_cells\n\t\t\tens_dict[\"total_snATAC_cells\"] = total_snATAC_cells\n\n\t\t\tif slices_set:\n\t\t\t\tens_regions_acronyms = aba_regions.set_index('code').loc[list(slices_set),'ABA_acronym'].values\n\t\t\t\tens_regions_descriptions = aba_regions.set_index('code').loc[list(slices_set),'ABA_description'].values\n\t\t\t\tens_dict[\"ABA_regions_acronym\"] = \", \".join(ens_regions_acronyms).replace('+',', ')\n\t\t\t\tens_dict[\"ABA_regions_description\"] = \", \".join(ens_regions_descriptions).replace('+',', ')\n\n\t\t\tif ens['public_access'] == 0:\n\t\t\t\tens_dict[\"public_access_icon\"] = \"fas fa-lock\"\n\t\t\t\tens_dict[\"public_access_color\"] = \"black\"\n\t\t\telse:\n\t\t\t\tens_dict[\"public_access_icon\"] = \"fas fa-lock-open\"\n\t\t\t\tens_dict[\"public_access_color\"] = \"green\"\n\n\t\t\tens_dict[\"annoj_exists\"] = ens['annoj_exists']\n\n\n\t\t\tuse_region=True\n\t\t\tif regions!=['none']:\n\t\t\t\tuse_region = use_region and (len([region for region in regions if region in ens_dict[\"ABA_regions_acronym\"].lower()])>0)\n\t\t\tif regions_tgt!=['none']:\n\t\t\t\tuse_region = use_region and (len([region_tgt for region_tgt in regions_tgt if region_tgt in ens_dict[\"target_regions_rs2_acronym\"].lower()])>0)\n\t\t\tif use_region:\n\t\t\t\tensembles_json_list.append(ens_dict)\n\n\tens_json = json.dumps(ensembles_json_list)\n\n\treturn ens_json","def get_gene_by_name(gene_query):\n\n\tgene_query = [ gene.lower()+\"%\" for gene in gene_query ]\n\n\tsql_query = \"SELECT * FROM genes WHERE \" + \"lower(gene_name) LIKE %s OR \" * len(gene_query)\n\tsql_query = sql_query[:-3]\n\n\tdf = pd.read_sql(sql_query, params=(gene_query,), con=db.get_engine(current_app, 'methylation_data'))\n\n\treturn df.to_dict('records')","async def test_get_transcripts_from_gene(test_db):\n resp = await test_db.get_transcripts_from_gene(\"BRAF\", 2145, 2145)\n assert len(resp) == 32\n\n resp = await test_db.get_transcripts_from_gene(\"BRAF\", 140453136,\n 140453136)\n assert len(resp) == 0","def getFasta(fileGI,fileout = \"gis.fasta\", outfmt = \"fasta\"):\n myGIs = open(fileGI).read().split()\n gilist = [\",\".join(myGIs[i:i+500]) for i in range(0,len(myGIs),500)]\n from Bio import Entrez\n import time\n fout = open(fileout,\"w\")\n Entrez.email = \"ks2074@gmail.com\"\n for ele in gilist:\n handle = Entrez.efetch(db = \"protein\", id = ele, rettype = outfmt, retmode = \"text\")\n fout.write(handle.read())\n time.sleep(3)\n fout.close()","def data(dataset=\"bio_eventrelated_100hz\"):\n # TODO: one could further improve this function with like\n # selectors 'ecg=True, eda=True, restingstate=True' that would\n # find the most appropriate dataset\n\n dataset = dataset.lower()\n\n # TODO: change this path back to \"master\"\n path = \"https://raw.githubusercontent.com/neuropsychology/NeuroKit/dev/data/\"\n\n # Signals as vectors =======================\n if dataset in [\"eeg\", \"eeg_150hz\", \"eeg.txt\"]:\n return pd.read_csv(path + \"eeg.txt\").values[:, 0]\n\n if dataset in [\"rsp\", \"rsp_1000hz\", \"rsp_1000hz.txt\"]:\n return pd.read_csv(path + \"rsp_1000hz.txt\", header=None).values[:, 0]\n\n if dataset in [\"ecg\", \"ecg_1000hz\", \"ecg_1000hz.csv\"]:\n return pd.read_csv(path + \"ecg_1000hz.csv\")[\"ECG\"].values\n\n if dataset in [\"ecg_3000hz\", \"ecg_3000hz.csv\"]:\n return pd.read_csv(path + \"ecg_1000hz.csv\")[\"ECG\"].values\n\n if dataset in [\"eog\", \"veog\", \"eog_100hz\", \"eog_100hz.csv\"]:\n return pd.read_csv(path + \"eog_100hz.csv\")[\"vEOG\"].values\n\n # Dataframes ===============================\n if dataset == \"iris\":\n info = sklearn_datasets.load_iris()\n data = pd.DataFrame(\n info.data, columns=[\"Sepal.Length\", \"Sepal.Width\", \"Petal.Length\", \"Petal.Width\"]\n )\n data[\"Species\"] = info.target_names[info.target]\n return data\n\n if dataset in [\"eogs\", \"eogs_200hz\", \"eog_200hz\", \"eog_200hz.csv\"]:\n return pd.read_csv(path + \"eog_200hz.csv\")\n\n # Add extension\n if dataset in [\"bio_resting_8min_200hz\"]:\n dataset += \".json\"\n\n # Specific case for json file\n if dataset.endswith(\".json\"):\n if \"https\" not in dataset:\n data = pd.read_json(path + dataset, orient=\"index\")\n else:\n data = pd.read_json(dataset, orient=\"index\")\n df = {}\n for participant, row in data.iterrows():\n for _, data_string in row.items():\n data_list = json.loads(data_string)\n data_pd = pd.DataFrame(data_list)\n df[participant] = data_pd\n\n return df\n\n # TODO: Add more EEG (fif and edf datasets)\n if dataset in [\"eeg_1min_200hz\"]:\n\n return pickle.load(\n urllib.request.urlopen(\n \"https://github.com/neuropsychology/NeuroKit/blob/dev/data/eeg_1min_200hz.pickle?raw=true\"\n )\n )\n\n # General case\n file, ext = os.path.splitext(dataset) # pylint: disable=unused-variable\n if ext == \"\":\n df = pd.read_csv(path + dataset + \".csv\")\n else:\n if \"https\" not in dataset:\n df = pd.read_csv(path + dataset)\n else:\n df = pd.read_csv(dataset)\n return df","def get_gloffis_data():\n data_params = DATASETS_VIS['gloffis']\n\n r = request.get_json()\n\n dataset = r['dataset']\n assert (dataset in data_params), '{} not in assets. '.format(dataset)\n data_params = data_params[dataset]\n\n band = r['band']\n assert band in data_params['bandNames'].keys(), '{} not in bands. '.format(band)\n\n # Get collection based on dataset requested\n collection = ee.ImageCollection(data_params['source'])\n\n if 'date' in r:\n start = ee.Date(r['date'])\n collection = collection.filterDate(start)\n # check that at least one image returned. If not, return error\n n_images = collection.size().getInfo()\n if not n_images:\n msg = 'No images available for time: %s' % (r['date'])\n logger.debug(msg)\n raise error_handler.InvalidUsage(msg)\n\n image = ee.Image(collection.sort('system:time_start', False).first())\n image_date = collection.sort('system:time_start', False).first().date().format().getInfo()\n\n image = image.select(band)\n\n vis_params = {\n 'min': data_params['min'][band],\n 'max': data_params['max'][band],\n 'palette': data_params['palette'][band]\n }\n\n if dataset == 'hydro':\n image = image.mask(image.gte(0))\n\n if band == 'discharge_routed_simulated':\n image = image.log()\n\n if 'min' in r:\n vis_params['min'] = r['min']\n\n if 'max' in r:\n vis_params['max'] = r['max']\n\n if 'palette' in r:\n vis_params['palette'] = r['palette']\n\n info = generate_image_info(image, vis_params)\n info['dataset'] = dataset\n info['band'] = band\n info['date'] = image_date\n\n if band == 'discharge_routed_simulated':\n info['min'] = 10**vis_params['min']\n info['max'] = 10**vis_params['max']\n\n return Response(\n json.dumps(info),\n status=200,\n mimetype='application/json'\n )","def getDataAt(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\n ...","def get_glossis_data():\n data_params = DATASETS_VIS['glossis']\n\n r = request.get_json()\n dataset = r['dataset']\n\n assert (dataset in data_params), '{} not in assets. '.format(dataset)\n data_params = data_params[dataset]\n # Get collection based on dataset requested\n collection = ee.ImageCollection(data_params['source'])\n\n if 'date' in r:\n start = ee.Date(r['date'])\n collection = collection.filterDate(start)\n # check that at least one image returned. If not, return error\n n_images = collection.size().getInfo()\n if not n_images:\n msg = 'No images available for time: %s' % (r['date'])\n logger.debug(msg)\n raise error_handler.InvalidUsage(msg)\n\n image = ee.Image(collection.sort('system:time_start', False).first())\n image_date = image.date().format().getInfo()\n # image_id = image.id().getInfo()\n\n # Generate image on dataset requested (characteristic to display)\n band = r.get('band', list(data_params['bandNames'].keys())[0])\n assert band in data_params['bandNames']\n\n\n if dataset in ['wind', 'currents']:\n function = r.get('function', 'magnitude')\n assert function in data_params['function']\n if function == 'magnitude':\n image = image.pow(2).reduce(ee.Reducer.sum()).sqrt()\n vis_params = {\n 'min': data_params['min'][function],\n 'max': data_params['max'][function],\n 'palette': data_params['palette'][function]\n }\n else:\n image = image.unitScale(data_params['min'][function], data_params['max'][function]).unmask(-9999)\n data_mask = image.eq(-9999).select(data_params['bandNames'][band])\n image = image.clamp(0, 1).addBands(data_mask)\n vis_params = {\n 'min': data_params['min'][function],\n 'max': data_params['max'][function]\n }\n else:\n image = image.select(data_params['bandNames'][band])\n vis_params = {\n 'min': data_params['min'][band],\n 'max': data_params['max'][band],\n 'palette': data_params['palette'][band]\n }\n\n if 'min' in r:\n vis_params['min'] = r['min']\n\n if 'max' in r:\n vis_params['max'] = r['max']\n\n if 'palette' in r:\n vis_params['palette'] = r['palette']\n\n info = generate_image_info(image, vis_params)\n info['dataset'] = dataset\n info['date'] = image_date\n # info['imageId'] = image_id\n # info['imageSource'] = data_params['source']\n\n return Response(\n json.dumps(info),\n status=200,\n mimetype='application/json'\n )","def data(self):","def index_gff(gff, logger):\n f_in = open(gff, \"r\")\n gene_start_stop_dict = dict()\n gene_scaff_dict = dict()\n gene_first_exon_dict = dict()\n gene_direction = dict()\n gene_gff_line = dict()\n gene_set = set([])\n for line in f_in:\n if line.startswith(\"#\"):\n continue\n if not line.strip():\n continue\n assert len(line.split(\"\\t\")) == 9 , \"GFF fields wrong length should be 9\"\n scaff, source, feature, start, stop, score, \\\n direction, frame, gene_info = line.split(\"\\t\")\n gene = split_gene_name(gene_info)\n scaff = scaff.rstrip()\n if feature == \"gene\":\n gene_gff_line[gene] = line\n gene_set.add(gene)\n start_stop = \"%s\\t%s\" % (start, stop)\n gene_start_stop_dict[gene] = start_stop\n gene_scaff_dict[gene] = scaff\n gene_direction[gene] = direction\n if not gene in gene_first_exon_dict.keys():\n if feature == \"exon\" or feature == \"CDS\":\n start_stop = \"%s\\t%s\" % (start, stop)\n gene_first_exon_dict[gene] = start_stop\n f_in.close()\n logger.info(\"Number of genes = %d\", len(gene_set))\n return gene_start_stop_dict, gene_first_exon_dict, \\\n gene_scaff_dict, gene_direction, gene_set, gene_gff_line","def _get_datas(self):\n print(f'base name {self.base_name}')\n data_file_name = glob(osp.join(self.root_dir, MERGED_PATTERN))[0]\n data_df = pd.read_csv(data_file_name)\n\n ppg_d = data_df[['CurrentTimeMillis', 'ch1']].values\n acc_d = data_df[[\n 'EventTimestamp(ns)', 'accel_x', 'accel_y', 'accel_z'\n ]].values\n ppg_d = ppg_d[::2]\n acc_d = acc_d[::2]\n\n return acc_d, ppg_d","def get_sequences(data_path, gene):\n \n sequence_file = os.path.join(data_path, gene + \".fasta\")\n try:\n sequences_gene = sequence.Sequence.create(file = sequence_file, input_format = 'fasta')\n except FileNotFoundError:\n print(\"Did not found {} in {}.\".format(gene,data_path))\n sequences_gene = \"Did not found {} in {}.\".format(gene,data_path)\n except:\n print(\"Unexpected Error while trying to get the sequence from {}.\".format(sequence_file))\n sequences_gene = \"Unexpected Error while trying to get the sequence from {}.\".format(sequence_file)\n # print(\"sequences_gene\", sequences_gene)\n return sequences_gene"],"string":"[\n \"def gene(self, idx):\\r\\n return self.genes[idx]\",\n \"async def test_get_gene_from_ac(test_db):\\n resp = await test_db.get_gene_from_ac(\\\"NC_000007.13\\\", 140453136, None)\\n assert resp == [\\\"BRAF\\\"]\\n\\n resp = await test_db.get_gene_from_ac(\\\"NC_000007.14\\\", 140753336, None)\\n assert resp == [\\\"BRAF\\\"]\\n\\n resp = await test_db.get_gene_from_ac(\\\"NC_000007.13\\\", 55249071, None)\\n assert resp == [\\\"EGFR\\\", \\\"EGFR-AS1\\\"]\\n\\n resp = await test_db.get_gene_from_ac(\\\"NC_0000078.1\\\", 140453136, None)\\n assert resp is None\",\n \"def get_entrezid(gene):\\n entrezurl = \\\"http://mygene.info/v3/query?q=\\\"\\n entrezurl = entrezurl+gene\\n\\n res = requests.get(entrezurl)\\n results = pandas.read_json(StringIO(res.text))\\n\\n entrezid = []\\n if results.empty:\\n return entrezid\\n\\n for i in results.ix[:, 0]:\\n key = i.keys()\\n value = i.values()\\n for cntr, k in enumerate(key):\\n if k == 'entrezgene':\\n entrezid.append(value[cntr])\\n return entrezid\",\n \"def GetGeData(self, *args, **kwargs):\\n pass\",\n \"def get_gene(gene):\\n\\n return copy.deepcopy(gene)\",\n \"def init_gene():\\n gene_details=dict(\\n id = '', \\n anno_id = [],\\n confgenes_id = [],\\n name = '',\\n source = '',\\n gene_info = {},\\n alias = '',\\n name2 = [],\\n strand = '',\\n chr = '',\\n chr_num = [],\\n paralogs = [],\\n start = '',\\n stop = '',\\n transcripts = [],\\n transcript_info = [],\\n transcript_status = [],\\n transcript_valid = [],\\n exons = [],\\n exons_confirmed = [],\\n cds_exons = [],\\n utr5_exons = [],\\n utr3_exons = [],\\n tis = [],\\n tis_conf = [],\\n tis_info = [],\\n cdsStop = [],\\n cdsStop_conf = [],\\n cdsStop_info = [],\\n tss = [],\\n tss_info = [],\\n tss_conf = [],\\n cleave = [],\\n cleave_info = [],\\n cleave_conf = [],\\n polya = [],\\n polya_info = [],\\n polya_conf = [],\\n is_alt = [],\\n is_alt_spliced = 0,\\n is_valid = [],\\n transcript_complete = [],\\n is_complete = [],\\n is_correctly_gff3_referenced = '',\\n splicegraph = []\\n )\\n return gene_details\",\n \"def get_data():\\n pass\",\n \"def get_gene(self):\\n return self._gene\",\n \"def read_dataset_v1():\\n path = load_config()\\n T = feather.read_dataframe(path['data_dir'] / 'T_dat.feather')\\n E = feather.read_dataframe(path['data_dir'] / 'E_dat.feather')\\n M = feather.read_dataframe(path['data_dir'] / 'Meta.feather')\\n data = sio.loadmat(path['data_dir'] / 'highvar_genes.mat', squeeze_me=True)\\n return T, E, M, data\",\n \"def get_results(self, preprocess=True):\\n logger.debug('Calculating GSEA')\\n measurement_df = self._get_measurement_df(preprocess)\\n\\n annot_df = self.data_source.get_annotations()\\n joined = pd.merge(left=measurement_df, right=annot_df, left_index=True, right_index=True)\\n joined = joined.set_index('entity_id')\\n unique_ids = [self.data_source._get_unique_id(x) for x in joined.index.values]\\n joined.index = unique_ids\\n joined = joined.drop_duplicates(keep='first').sort_index()\\n\\n # gene_sets is a dict. key is pw name, values are a list of entries in that pathway\\n gene_sets = {}\\n assert len(self.data_source.dataset_pathways) > 0, 'No pathways found in the dataset'\\n pathways = list(self.data_source.dataset_pathways)\\n for pw in pathways:\\n pathway_row_ids = self.data_source.dataset_pathways_to_row_ids[pw]\\n pw_unique_ids = []\\n for row_id in pathway_row_ids:\\n pw_unique_ids.extend(self.data_source.dataset_row_id_to_unique_ids[row_id])\\n pw_unique_ids = list(set(pw_unique_ids))\\n gene_sets[pw] = pw_unique_ids\\n\\n # run GSEA for all comparisons\\n all_dfs = []\\n for comp in self.data_source.comparisons:\\n if not is_comparison_used(comp, self.case, self.control):\\n continue\\n case = comp['case']\\n control = comp['control']\\n logger.debug('Running comparison case=%s control=%s' % (case, control))\\n pheno_cols = set(self.data_source.get_experimental_design()['groups'][case])\\n df_cols = measurement_df.columns.values\\n\\n # for each comparison, we need to create C (phenotype labels)\\n # Loop over df_cols and store an indicator into C.\\n # Entries in C is 1 if that column belongs to the case group, otherwise it's a 0\\n C = []\\n for col in df_cols:\\n if col in pheno_cols:\\n C.append(1)\\n else:\\n C.append(0)\\n C = np.array(C)\\n\\n # actually runs GSEA here\\n data = joined\\n cls = C.tolist()\\n outdir = None\\n min_size = 1\\n max_size = 1000\\n permutation_num = self.num_resamples\\n weighted_score_type = 1\\n permutation_type = 'phenotype'\\n method = self.method\\n ascending = True\\n processes = 1\\n figsize = (6.5, 6)\\n format = 'pdf',\\n graph_num = 20\\n no_plot = True\\n seed = None\\n verbose = False\\n\\n msea = MSEA(data, gene_sets, cls, outdir, min_size, max_size, permutation_num,\\n weighted_score_type, permutation_type, method, ascending, processes,\\n figsize, format, graph_num, no_plot, seed, verbose)\\n msea.run()\\n\\n # convert GSEA results to dataframe\\n df = msea.res2d\\n df = df.reset_index()\\n selected = df[['Term', 'pval', 'fdr', 'es']]\\n selected = selected.rename(columns={'Term': 'mapids'}).set_index('mapids')\\n\\n col_name = comp['name'] + ' p-value'\\n es_colname = comp['name'] + ' ES_score'\\n if self.data_source.database_name is not None:\\n comb_col_name = '%s %s %s' % (self.data_source.database_name, comp['name'], 'comb_p')\\n else:\\n comb_col_name = '%s %s' % (comp['name'], 'comb_p')\\n\\n pathway_df = selected.rename(columns={\\n 'pval': col_name,\\n 'es': es_colname,\\n 'fdr': comb_col_name\\n })\\n all_dfs.append(pathway_df)\\n\\n # combine all the results across all comparisons\\n combined_df = pd.concat(all_dfs, axis=1, sort=False)\\n combined_df.index.name = 'mapids'\\n\\n # create a dataframe of pathway mapids and names\\n pw_name_df = []\\n for map_id in pathways:\\n pw_name = self.data_source.pathway_dict[map_id]['display_name']\\n pw_name_df.append((map_id, pw_name))\\n pw_name_df = pd.DataFrame(pw_name_df, columns=['mapids', 'pw_name']).set_index(['mapids'])\\n combined_df = pw_name_df.merge(combined_df, left_index=True, right_index=True)\\n\\n # add formula coverage information\\n mapids = combined_df.index.values.tolist()\\n cov_df = self.data_source._calculate_coverage_df(mapids)\\n coverage_df = cov_df.reindex(combined_df.index) # make sure dfs are in same order before merging\\n\\n # Merge the two dfs together\\n pathway_df = pd.merge(combined_df, coverage_df, left_index=True, right_index=True, how='outer')\\n\\n # del pathway_df.index.name\\n pathway_df.rename_axis(None, inplace=True)\\n\\n # post-processing to filter pathway dataframe by the minimum number of hits\\n pathway_df = post_filter_df_by_min_hits(pathway_df, self.data_source.min_hits)\\n return pathway_df\",\n \"def extract_gene_data(info):\\n gene_id = None\\n gene_type = None\\n for i in info:\\n if i.startswith('gene_id'):\\n gene_id = i.split(\\\" \\\", 1)[1].replace('\\\"', '')\\n elif i.startswith('gene_type'):\\n gene_type = i.split(\\\" \\\", 1)[1].replace('\\\"', '')\\n\\n assert gene_id is not None, 'No gene_id found {0}'.format(info)\\n assert gene_type is not None, 'No gene_type found {0}'.format(info)\\n return gene_id, gene_type\",\n \"def get_gene_snatac_from_mysql(ensemble, gene_table_name, counts_type, tsne_type, max_points='10000', modality='snATAC'):\\n\\n\\tt0=datetime.datetime.now()\\n\\tif tsne_type=='noTSNE':\\n\\t\\tquery = \\\"SELECT %(gene_table_name)s.%(counts_type)s as normalized_counts \\\\\\n\\t\\t\\tFROM %(ensemble)s \\\\\\n\\t\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\" % {'ensemble': ensemble, \\n\\t\\t\\t 'gene_table_name': gene_table_name,\\n\\t\\t\\t 'counts_type': counts_type,}\\n\\telse:\\n\\t\\tquery = \\\"SELECT cells.cell_id, cells.cell_name, cells.dataset, \\\\\\n\\t\\t\\t%(ensemble)s.annotation_%(modality)s, %(ensemble)s.cluster_%(modality)s, \\\\\\n\\t\\t\\t%(ensemble)s.tsne_x_%(modality)s, %(ensemble)s.tsne_y_%(modality)s, \\\\\\n\\t\\t\\t%(gene_table_name)s.%(counts_type)s as normalized_counts, \\\\\\n\\t\\t\\tdatasets.target_region \\\\\\n\\t\\t\\tFROM cells \\\\\\n\\t\\t\\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN datasets ON cells.dataset = datasets.dataset\\\" % {'ensemble': ensemble,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'gene_table_name': gene_table_name,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'counts_type': counts_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'modality': modality,}\\n\\tif max_points.isdigit():\\n\\t\\tquery = query+\\\" ORDER BY RAND() LIMIT %(max_points)s\\\" % {'max_points': max_points}\\n\\n\\ttry:\\n\\t\\tdf = pd.read_sql(query, db.get_engine(current_app, modality+'_data'))\\n\\texcept exc.ProgrammingError as e:\\n\\t\\tnow = datetime.datetime.now()\\n\\t\\tprint(\\\"[{}] ERROR in app(get_gene_snatac_from_mysql): {}\\\".format(str(now), e))\\n\\t\\tsys.stdout.flush()\\n\\t\\treturn None\\n\\n\\tt1=datetime.datetime.now()\\n\\n\\treturn df\",\n \"def extract_data( galaxy_ID):\\n\\n data_cube = marvin.tools.Maps( galaxy_ID)\\n\\n #ssp = main_file[1].data\\n #flux_elines = main_file[3].data\\n #org_hdr = main_file[0].header\\n\\n ###########################################################################\\n # NOTE: The visual band fluxes are multiplied by 10^-16 as stated in the\\n # units of the MaNGA Data Model.\\n #\\n # <https://data.sdss.org/datamodel/files/MANGA_PIPE3D/MANGADRP_VER\\n # /PIPE3D_VER/PLATE/manga.Pipe3D.cube.html#hdu1>\\n ###########################################################################\\n #v_band = ssp[0] # in units of erg / s / cm^2\\n #v_band_err = ssp[4] # in units of erg / s / cm^2\\n #sMass_density = ssp[19] * u.dex( u.M_sun) # in units of log10( Msun / spaxel**2)\\n\\n Ha_vel = data_cube.emlines_gvel_ha_6564 # in units of km/s\\n Ha_vel_err = data_cube.emlines_g # in units of km/s\\n\\n manga_plate = org_hdr['PLATEID']\\n manga_fiberID = org_hdr['IFUDSGN']\\n gal_ra = org_hdr['OBJRA']\\n gal_dec = org_hdr['OBJDEC']\\n\\n return Ha_vel, Ha_vel_err, v_band, v_band_err, sMass_density, manga_plate, \\n manga_fiberID, gal_ra, gal_dec\",\n \"def getFirstData(self) -> ghidra.program.model.listing.Data:\\n ...\",\n \"def get_data():\\n return\",\n \"def data(self):\\n return self._data.iloc[:, : self.n_genes]\",\n \"def _get_gedi1b_main_data_dict(self) -> dict:\\n data = {\\n # General identifiable data\\n \\\"granule_name\\\": [self.parent_granule.filename] * self.n_shots,\\n \\\"shot_number\\\": self[\\\"shot_number\\\"][:],\\n \\\"beam_type\\\": [self.beam_type] * self.n_shots,\\n \\\"beam_name\\\": [self.name] * self.n_shots,\\n # Temporal data\\n \\\"delta_time\\\": self[\\\"delta_time\\\"][:],\\n # Quality data\\n \\\"degrade\\\": self[\\\"geolocation/degrade\\\"][:],\\n \\\"stale_return_flag\\\": self[\\\"stale_return_flag\\\"][:],\\n \\\"solar_elevation\\\": self[\\\"geolocation/solar_elevation\\\"][:],\\n \\\"solar_azimuth\\\": self[\\\"geolocation/solar_elevation\\\"][:],\\n \\\"rx_energy\\\": self[\\\"rx_energy\\\"][:],\\n # DEM\\n \\\"dem_tandemx\\\": self[\\\"geolocation/digital_elevation_model\\\"][:],\\n \\\"dem_srtm\\\": self[\\\"geolocation/digital_elevation_model_srtm\\\"][:],\\n # geolocation bin0\\n \\\"latitude_bin0\\\": self[\\\"geolocation/latitude_bin0\\\"][:],\\n \\\"latitude_bin0_error\\\": self[\\\"geolocation/latitude_bin0_error\\\"][:],\\n \\\"longitude_bin0\\\": self[\\\"geolocation/longitude_bin0\\\"][:],\\n \\\"longitude_bin0_error\\\": self[\\\"geolocation/longitude_bin0_error\\\"][:],\\n \\\"elevation_bin0\\\": self[\\\"geolocation/elevation_bin0\\\"][:],\\n \\\"elevation_bin0_error\\\": self[\\\"geolocation/elevation_bin0_error\\\"][:],\\n # geolocation lastbin\\n \\\"latitude_lastbin\\\": self[\\\"geolocation/latitude_lastbin\\\"][:],\\n \\\"latitude_lastbin_error\\\": self[\\\"geolocation/latitude_lastbin_error\\\"][:],\\n \\\"longitude_lastbin\\\": self[\\\"geolocation/longitude_lastbin\\\"][:],\\n \\\"longitude_lastbin_error\\\": self[\\\"geolocation/longitude_lastbin_error\\\"][:],\\n \\\"elevation_lastbin\\\": self[\\\"geolocation/elevation_lastbin\\\"][:],\\n \\\"elevation_lastbin_error\\\": self[\\\"geolocation/elevation_lastbin_error\\\"][:],\\n # relative waveform position info in beam and ssub-granule\\n \\\"waveform_start\\\": self[\\\"rx_sample_start_index\\\"][:] - 1,\\n \\\"waveform_count\\\": self[\\\"rx_sample_count\\\"][:],\\n }\\n return data\",\n \"def test_get_genome_7(self):\\n self.tkt1.data_add = set([\\\"retrieve_record\\\"])\\n gnm = tickets.get_genome(self.tkt1, gnm_type=\\\"add\\\")\\n with self.subTest():\\n self.assertEqual(gnm.host_genus, \\\"\\\")\\n with self.subTest():\\n self.assertEqual(gnm.retrieve_record, 1)\",\n \"def get_mult_gene_snATAC(ensemble, genes, grouping, smoothing=False, max_points='10000', modality='snATAC'):\\n\\n\\t# Prevent SQL injected since column names cannot be parameterized.\\n\\tif \\\";\\\" in ensemble or \\\";\\\" in grouping:\\n\\t\\treturn None\\n\\n\\tgenes = [gene+\\\"%\\\" for gene in genes]\\n\\n\\t# This query is just to fix gene id's missing the ensemble version number.\\n\\t# Necessary because the table name must match exactly with whats on the MySQL database.\\n\\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3\\n\\tfirst_query = \\\"SELECT gene_id FROM genes WHERE gene_id LIKE %s\\\" + \\\" OR gene_id LIKE %s\\\" * (len(genes)-1)\\n\\tresult = db.get_engine(current_app, 'methylation_data').execute(first_query, (genes,)).fetchall()\\n\\n\\tgene_table_names = ['gene_' + gene_id[0].replace('.','_') for gene_id in result]\\n\\n\\tdf_all = pd.DataFrame()\\n\\n\\tif smoothing:\\n\\t\\tcounts_type='smoothed_normalized_counts'\\n\\telse:\\n\\t\\tcounts_type='normalized_counts'\\n\\n\\tt0=datetime.datetime.now()\\n\\tdf_list = []\\n\\tdf = get_gene_snatac_from_mysql(ensemble, gene_table_names[0], counts_type, 'TSNE', max_points)\\n\\tdf_all = df_all.append(df)\\n\\tdf_coords = df;\\n\\tfor gene_table_name in gene_table_names[1:]:\\n\\t\\tdf_all = df_all.append(get_gene_snatac_from_mysql(ensemble, gene_table_name, counts_type, 'noTSNE', max_points))\\n\\n\\tt1=datetime.datetime.now()\\n\\n\\tt1=datetime.datetime.now()\\n\\n\\tif df_all.empty: # If no data in column, return None\\n\\t\\tnow = datetime.datetime.now()\\n\\t\\tprint(\\\"[{}] ERROR in app(get_gene_snATAC): No snATAC data for {}\\\".format(str(now), ensemble))\\n\\t\\tsys.stdout.flush()\\n\\t\\treturn None\\n\\n\\tdf_all['normalized_counts'].fillna(0, inplace=True)\\n\\n\\tdf_avg_methylation = df_all.groupby(by='cell_id', as_index=False)['normalized_counts'].mean()\\n\\tdf_coords.update(df_avg_methylation)\\n\\n\\tif grouping == 'annotation':\\n\\t\\tdf_coords.fillna({'annotation_ATAC': 'None'}, inplace=True)\\n\\t\\tdf_coords['annotation_cat'] = pd.Categorical(df_coords['annotation_ATAC'], cluster_annotation_order)\\n\\t\\tdf_coords.sort_values(by='annotation_cat', inplace=True)\\n\\t\\tdf_coords.drop('annotation_cat', axis=1, inplace=True)\\n\\telif grouping == 'cluster':\\n\\t\\tdf_coords.sort_values(by='cluster_ATAC', inplace=True)\\n\\treturn df_coords\",\n \"def get_gene_snATAC(ensemble, gene, grouping, outliers, smoothing=False, max_points='10000', \\n\\tmodality='snATAC'):\\n\\tmodalityu = modality.replace('snATAC','ATAC').replace('snRNA','RNA')\\n\\n\\t# Prevent SQL injected since column names cannot be parameterized.\\n\\tif \\\";\\\" in ensemble or \\\";\\\" in grouping:\\n\\t\\treturn None\\n\\n\\t# This query is just to fix gene id's missing the ensemble version number.\\n\\t# Necessary because the table name must match exactly with whats on the MySQL database.\\n\\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3 -> gene_ENSMUSG00000026787_3 (table name in MySQL)\\n\\tresult = db.get_engine(current_app, modality+'_data').execute(\\\"SELECT gene_id FROM genes WHERE gene_id LIKE %s\\\", (gene+\\\"%\\\",)).fetchone()\\n\\tgene_table_name = 'gene_' + result['gene_id'].replace('.','_')\\n\\n\\tif smoothing and (modalityu=='ATAC'):\\n\\t\\tcounts_type='smoothed_normalized_counts'\\n\\telse:\\n\\t\\tcounts_type='normalized_counts'\\n\\n\\tquery = \\\"SELECT cells.cell_id, cells.cell_name, cells.dataset, \\\\\\n\\t\\t%(ensemble)s.annotation_%(modality)s, %(ensemble)s.cluster_%(modality)s, \\\\\\n\\t\\t%(ensemble)s.tsne_x_%(modality)s, %(ensemble)s.tsne_y_%(modality)s, \\\\\\n\\t\\t%(gene_table_name)s.%(counts_type)s as normalized_counts, \\\\\\n\\t\\tdatasets.target_region \\\\\\n\\t\\tFROM cells \\\\\\n\\t\\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\\\\n\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\\\\n\\t\\tLEFT JOIN datasets ON cells.dataset = datasets.dataset\\\" % {'ensemble': ensemble,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t'gene_table_name': gene_table_name,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t'counts_type': counts_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t'modality': modalityu}\\n\\n\\tif max_points.isdigit():\\n\\t\\tquery = query+\\\" ORDER BY RAND() LIMIT %(max_points)s\\\" % {'max_points': max_points}\\n\\n\\ttry:\\n\\t\\tdf = pd.read_sql(query, db.get_engine(current_app, '%s_data' % modality))\\n\\texcept exc.ProgrammingError as e:\\n\\t\\tnow = datetime.datetime.now()\\n\\t\\tprint(\\\"[{}] ERROR in app(get_gene_snATAC): {}\\\".format(str(now), e))\\n\\t\\tsys.stdout.flush()\\n\\t\\treturn None\\n\\n\\tif df.empty: # If no data in column, return None\\n\\t\\tnow = datetime.datetime.now()\\n\\t\\tprint(\\\"[{}] ERROR in app(get_gene_snATAC): No snATAC data for {}\\\".format(str(now), ensemble))\\n\\t\\tsys.stdout.flush()\\n\\t\\treturn None\\n\\n\\tif grouping == 'annotation':\\n\\t\\tdf.fillna({'annotation_%s' % modality: 'None'}, inplace=True)\\n\\t\\tdf['annotation_cat'] = pd.Categorical(df['annotation_%s' % modality], cluster_annotation_order)\\n\\t\\tdf.sort_values(by='annotation_cat', inplace=True)\\n\\t\\tdf.drop('annotation_cat', axis=1, inplace=True)\\n\\telif grouping == 'cluster':\\n\\t\\tdf.sort_values(by='cluster_%s' % modality, inplace=True)\\n\\n\\tdf['normalized_counts'].fillna(0, inplace=True)\\n\\n\\treturn df\",\n \"def get_data(self):\",\n \"def get_gaia_data(ra, dec, search_radius=10.):\\n # Get the positions of the Gaia sources\\n c1 = SkyCoord(ra, dec, frame='icrs', unit='deg')\\n # We are querying with a diameter as the radius, overfilling by 2x.\\n from astroquery.vizier import Vizier\\n Vizier.ROW_LIMIT = -1\\n if args.DR2:\\n gaia_cat, catID = \\\"I/345/gaia2\\\", \\\"DR2\\\"\\n print('\\\\t --> Using Gaia DR2 as requested by user...')\\n else:\\n gaia_cat, catID = \\\"I/355/gaiadr3\\\", \\\"DR3\\\"\\n\\n result = Vizier.query_region(c1, catalog=[gaia_cat],\\n radius=Angle(search_radius, \\\"arcsec\\\"))\\n try:\\n \\tresult = result[gaia_cat]\\n except:\\n print('Not in Gaia '+catID+'. If you know the Gaia ID and Gmag, try the options --gid and --gmag.')\\n print('Exiting without finishing...')\\n sys.exit()\\n\\n no_targets_found_message = ValueError('Either no sources were found in the query region '\\n 'or Vizier is unavailable')\\n too_few_found_message = ValueError('No sources found closer than 1 arcsec to TPF coordinates')\\n if result is None:\\n raise no_targets_found_message\\n elif len(result) == 0:\\n raise too_few_found_message\\n\\n if len(result)>1:\\n dist = np.sqrt((result['RA_ICRS']-ra)**2 + (result['DE_ICRS']-dec)**2)\\n idx = np.where(dist == np.min(dist))[0][0]\\n return result[idx]['Source'], result[idx]['Gmag']\\n else:\\n return result[0]['Source'], result[0]['Gmag']\",\n \"async def test_get_ac_from_gene(test_db):\\n resp = await test_db.get_ac_from_gene(\\\"BRAF\\\")\\n assert resp == [\\\"NC_000007.14\\\", \\\"NC_000007.13\\\"]\\n\\n resp = await test_db.get_ac_from_gene(\\\"HRAS\\\")\\n assert resp == [\\\"NC_000011.10\\\", \\\"NC_000011.9\\\"]\\n\\n resp = await test_db.get_ac_from_gene(\\\"dummy\\\")\\n assert resp == []\",\n \"def get_gene_RNA(ensemble, gene, grouping, outliers, max_points='10000', smoothing=False, modality='RNA'):\\n\\n\\t# Prevent SQL injected since column names cannot be parameterized.\\n\\tif \\\";\\\" in ensemble or \\\";\\\" in grouping:\\n\\t\\treturn None\\n\\n\\t# This query is just to fix gene id's missing the ensemble version number.\\n\\t# Necessary because the table name must match exactly with whats on the MySQL database.\\n\\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3 -> gene_ENSMUSG00000026787_3 (table name in MySQL)\\n\\tresult = db.get_engine(current_app, 'RNA_data').execute(\\\"SELECT gene_id FROM genes WHERE gene_id LIKE %s\\\", (gene+\\\"%\\\",)).fetchone()\\n\\tgene_table_name = 'gene_' + result['gene_id'].replace('.','_')\\n\\n\\tquery = \\\"SELECT cells.cell_id, cells.cell_name, cells.dataset, \\\\\\n\\t\\t%(ensemble)s.annotation_RNA, %(ensemble)s.cluster_RNA, \\\\\\n\\t\\t%(ensemble)s.tsne_x_RNA, %(ensemble)s.tsne_y_RNA, \\\\\\n\\t\\t%(gene_table_name)s.normalized_counts, \\\\\\n\\t\\tdatasets.target_region \\\\\\n\\t\\tFROM cells \\\\\\n\\t\\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\\\\n\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\\\\n\\t\\tLEFT JOIN datasets ON cells.dataset = datasets.dataset\\\" % {'ensemble': ensemble,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'gene_table_name': gene_table_name}\\n\\tif max_points.isdigit():\\n\\t\\tquery = query+\\\" ORDER BY RAND() LIMIT %(max_points)s\\\" % {'max_points': max_points}\\n\\n\\ttry:\\n\\t\\tdf = pd.read_sql(query, db.get_engine(current_app, 'RNA_data'))\\n\\texcept exc.ProgrammingError as e:\\n\\t\\tnow = datetime.datetime.now()\\n\\t\\tprint(\\\"[{}] ERROR in app(get_gene_RNA): {}\\\".format(str(now), e))\\n\\t\\tsys.stdout.flush()\\n\\t\\treturn None\\n\\n\\tif df.empty: # If no data in column, return None\\n\\t\\tnow = datetime.datetime.now()\\n\\t\\tprint(\\\"[{}] ERROR in app(get_gene_RNA): No RNA data for {}\\\".format(str(now), ensemble))\\n\\t\\tsys.stdout.flush()\\n\\t\\treturn None\\n\\n\\tif grouping == 'annotation':\\n\\t\\tdf.fillna({'annotation_RNA': 'None'}, inplace=True)\\n\\t\\tdf['annotation_cat'] = pd.Categorical(df['annotation_RNA'], cluster_annotation_order)\\n\\t\\tdf.sort_values(by='annotation_cat', inplace=True)\\n\\t\\tdf.drop('annotation_cat', axis=1, inplace=True)\\n\\telif grouping == 'cluster':\\n\\t\\tdf.sort_values(by='cluster_RNA', inplace=True)\\n\\n\\tdf['normalized_counts'].fillna(0, inplace=True)\\n\\n\\treturn df\",\n \"def gene(self):\\n\\t\\tif self._record is None:\\n\\t\\t\\treturn []\\n\\t\\tgene_list =[i for i in self._record.features if i.type == 'gene']\\n\\t\\treturn gene_list\",\n \"def get_gene_from_mysql(ensemble, gene_table_name, methylation_type, clustering, tsne_type, grouping='cluster', max_points='10000'):\\n\\n\\tcontext = methylation_type[1:]\\n\\tif grouping in ['annotation','cluster']:\\n\\t\\tgroupingu = ensemble+\\\".\\\"+grouping+\\\"_\\\"+clustering\\n\\telif grouping in ['NeuN']:\\n\\t\\tgroupingu = \\\"CONCAT('NeuN',cells.\\\"+grouping+\\\")\\\"\\n\\telif grouping in ['dataset','sex','brain_region','target_region']:\\n\\t\\tgroupingu = \\\"datasets.\\\"+grouping\\n\\telif grouping in ['broad_brain_region']:\\n\\t\\tgroupingu = \\\"ABA_regions.ABA_broad_acronym\\\"\\n\\telse:\\n\\t\\tgroupingu = \\\"cells.\\\"+grouping\\n\\n\\n\\tt0=datetime.datetime.now()\\n\\t# print(' Running get_gene_from_mysql for '+gene_table_name+' : '+str(t0)+'; ', file=open(log_file,'a'))# EAM - Profiling SQL\\n\\tif tsne_type=='noTSNE':\\n\\t\\tquery = \\\"SELECT %(gene_table_name)s.%(methylation_type)s, %(gene_table_name)s.%(context)s \\\\\\n\\t\\t\\tFROM %(ensemble)s \\\\\\n\\t\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id\\\" % {'ensemble': ensemble,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'gene_table_name': gene_table_name,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'methylation_type': methylation_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'context': context,}\\n\\telif 'ndim2' in tsne_type:\\n\\t\\tquery = \\\"SELECT cells.cell_id, cells.dataset, %(ensemble)s.cluster_%(clustering)s, datasets.target_region, \\\\\\n\\t\\t\\t%(ensemble)s.annotation_%(clustering)s, %(gene_table_name)s.%(methylation_type)s, \\\\\\n\\t\\t\\tcells.global_%(methylation_type)s, %(groupingu)s as grouping, \\\\\\n\\t\\t\\t%(ensemble)s.tsne_x_%(tsne_type)s, %(ensemble)s.tsne_y_%(tsne_type)s, \\\\\\n\\t\\t\\t%(gene_table_name)s.%(context)s, datasets.sex \\\\\\n\\t\\t\\tFROM cells \\\\\\n\\t\\t\\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN datasets ON cells.dataset = datasets.dataset \\\\\\n\\t\\t\\tLEFT JOIN ABA_regions ON datasets.brain_region=ABA_regions.ABA_acronym \\\" % {'ensemble': ensemble, 'groupingu': groupingu,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'gene_table_name': gene_table_name,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'tsne_type': tsne_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'methylation_type': methylation_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'context': context,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'clustering': clustering,}\\n\\telse: # 3D tSNE\\n\\t\\tquery = \\\"SELECT cells.cell_id, cells.cell_name, cells.dataset, cells.global_%(methylation_type)s, \\\\\\n\\t\\t\\t%(ensemble)s.annotation_%(clustering)s, %(ensemble)s.cluster_%(clustering)s, \\\\\\n\\t\\t\\t%(ensemble)s.tsne_x_%(tsne_type)s, %(ensemble)s.tsne_y_%(tsne_type)s, %(ensemble)s.tsne_z_%(tsne_type)s, \\\\\\n\\t\\t\\t%(gene_table_name)s.%(methylation_type)s, %(gene_table_name)s.%(context)s, \\\\\\n\\t\\t\\tdatasets.target_region, datasets.sex \\\\\\n\\t\\t\\tFROM cells \\\\\\n\\t\\t\\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\" % {'ensemble': ensemble,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'gene_table_name': gene_table_name,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'tsne_type': tsne_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'methylation_type': methylation_type,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'context': context,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'clustering': clustering,}\\n\\tif max_points.isdigit():\\n\\t\\tquery = query+\\\" ORDER BY RAND() LIMIT %(max_points)s\\\" % {'max_points': max_points}\\n\\n\\ttry:\\n\\t\\tdf = pd.read_sql(query, db.get_engine(current_app, 'methylation_data'))\\n\\texcept exc.ProgrammingError as e:\\n\\t\\tnow = datetime.datetime.now()\\n\\t\\tprint(\\\"[{}] ERROR in app(get_mult_gene_methylation): {}\\\".format(str(now), e))\\n\\t\\tsys.stdout.flush()\\n\\t\\treturn None\\n\\n\\treturn df\",\n \"def get_gene(identifier):\\n for store in [GENES, ALIASES]:\\n genes = store.get(identifier, None)\\n if genes and len(genes) == 1:\\n return genes\\n else:\\n raise ValueError('gene reference does not exist or refers to multiple genes')\",\n \"def _gene_ann(gene_ann_path):\\n gene_ann = pd.read_csv(gene_ann_path)\\n protein_gene = gene_ann[gene_ann.gene_type ==\\n 'protein_coding'].gene_name.tolist()\\n return(protein_gene)\",\n \"async def test_get_genomic_tx_data(test_db, genomic_tx_data):\\n resp = await test_db.get_genomic_tx_data(\\\"NM_004333.4\\\", (2145, 2145))\\n assert resp == {\\n \\\"gene\\\": \\\"BRAF\\\",\\n \\\"strand\\\": \\\"-\\\",\\n \\\"tx_pos_range\\\": (2053, 2188),\\n \\\"alt_pos_range\\\": (140739811, 140739946),\\n \\\"alt_aln_method\\\": \\\"splign\\\",\\n \\\"tx_exon_id\\\": 780496,\\n \\\"alt_exon_id\\\": 6619852,\\n \\\"tx_ac\\\": \\\"NM_004333.4\\\",\\n \\\"alt_ac\\\": \\\"NC_000007.14\\\",\\n \\\"pos_change\\\": (92, 43),\\n \\\"alt_pos_change_range\\\": (140739854, 140739854)\\n }\",\n \"def _get_gedi2a_main_data_dict(self) -> dict:\\n gedi_l2a_count_start = pd.to_datetime(\\\"2018-01-01T00:00:00Z\\\")\\n data = {\\n # General identifiable data\\n \\\"granule_name\\\": [self.parent_granule.filename] * self.n_shots,\\n \\\"shot_number\\\": self[\\\"shot_number\\\"][:],\\n \\\"beam_type\\\": [self.beam_type] * self.n_shots,\\n \\\"beam_name\\\": [self.name] * self.n_shots,\\n # Temporal data\\n \\\"delta_time\\\": self[\\\"delta_time\\\"][:],\\n \\\"absolute_time\\\": (\\n gedi_l2a_count_start\\n + pd.to_timedelta(list(self[\\\"delta_time\\\"]), unit=\\\"seconds\\\")\\n ),\\n # Quality data\\n \\\"sensitivity\\\": self[\\\"sensitivity\\\"][:],\\n \\\"quality_flag\\\": self[\\\"quality_flag\\\"][:],\\n \\\"solar_elevation\\\": self[\\\"solar_elevation\\\"][:],\\n \\\"solar_azimuth\\\": self[\\\"solar_elevation\\\"][:],\\n \\\"energy_total\\\": self[\\\"energy_total\\\"][:],\\n # DEM\\n \\\"dem_tandemx\\\": self[\\\"digital_elevation_model\\\"][:],\\n \\\"dem_srtm\\\": self[\\\"digital_elevation_model_srtm\\\"][:],\\n # Processing data\\n \\\"selected_algorithm\\\": self[\\\"selected_algorithm\\\"][:],\\n \\\"selected_mode\\\": self[\\\"selected_mode\\\"][:],\\n # Geolocation data\\n \\\"lon_lowestmode\\\": self[\\\"lon_lowestmode\\\"][:],\\n \\\"longitude_bin0_error\\\": self[\\\"longitude_bin0_error\\\"][:],\\n \\\"lat_lowestmode\\\": self[\\\"lat_lowestmode\\\"][:],\\n \\\"latitude_bin0_error\\\": self[\\\"latitude_bin0_error\\\"][:],\\n \\\"elev_lowestmode\\\": self[\\\"elev_lowestmode\\\"][:],\\n \\\"elevation_bin0_error\\\": self[\\\"elevation_bin0_error\\\"][:],\\n \\\"lon_highestreturn\\\": self[\\\"lon_highestreturn\\\"][:],\\n \\\"lat_highestreturn\\\": self[\\\"lat_highestreturn\\\"][:],\\n \\\"elev_highestreturn\\\": self[\\\"elev_highestreturn\\\"][:],\\n } | {f\\\"rh{i}\\\": self[\\\"rh\\\"][:, i] for i in range(101)}\\n return data\",\n \"def readOneData(self):\\n\\t\\tpass\",\n \"def get_gene(self, gene_id, source=\\\"eid\\\"):\\n\\n gene_id = str(gene_id)\\n\\n \\n try:\\n valid_gene = self.gene_cache[self.source_cache[source][gene_id]]\\n return valid_gene\\n except KeyError:\\n pass\\n \\n valid_eid = None\\n\\n if source == \\\"eid\\\":\\n try:\\n eid = int(gene_id)\\n except ValueError:\\n raise ValueError(\\\"gene_id must be an integer if source \\\" + \\\\\\n \\\"is \\\\\\\"Entrez\\\\\\\"\\\")\\n\\n self.cursor.execute(\\\"\\\"\\\"\\n SELECT EXISTS(\\n SELECT * \\n FROM genes \\n WHERE entrez_id = %(eid)s\\n )\\\"\\\"\\\", {'eid': eid})\\n if self.cursor.fetchone()[0] == 1:\\n valid_eid = eid\\n\\n else:\\n\\n self.cursor.execute(\\\"\\\"\\\"\\n SELECT entrez_id\\n FROM discontinued_genes\\n WHERE discontinued_id = %(eid)s\\\"\\\"\\\", {'eid': eid})\\n row = self.cursor.fetchone()\\n if row is not None:\\n valid_eid = row[0]\\n else:\\n raise KeyError(\\\"Entrez ID %d was not found in the database\\\" % eid)\\n\\n elif source == \\\"symbol\\\":\\n\\n args = {\\\"symbol\\\": gene_id}\\n self.cursor.execute(\\\"\\\"\\\"\\n SELECT entrez_id\\n FROM genes\\n WHERE symbol = %(symbol)s\\\"\\\"\\\", args)\\n row = self.cursor.fetchone()\\n if row is not None:\\n valid_eid = row[0]\\n else:\\n self.cursor.execute(\\\"\\\"\\\"\\n SELECT entrez_id\\n FROM discontinued_genes\\n WHERE discontinued_symbol = %(symbol)s\\\"\\\"\\\", args)\\n row = self.cursor.fetchone()\\n if row is not None:\\n valid_eid = row[0]\\n else:\\n self.cursor.execute(\\\"\\\"\\\"\\n SELECT entrez_id\\n FROM gene_synonyms\\n WHERE symbol = %(symbol)s\\\"\\\"\\\", args)\\n row = self.cursor.fetchone()\\n if row is not None:\\n valid_eid = row[0]\\n else:\\n raise KeyError(\\\"Symbol %s not found in the database\\\" % gene_id)\\n else:\\n self.cursor.execute(\\\"\\\"\\\"\\n SELECT entrez_id\\n FROM gene_xrefs\\n WHERE Xref_db = %(db)s\\n AND Xref_id = %(id)s\\\"\\\"\\\", {'db': source, 'id': gene_id})\\n row = self.cursor.fetchone()\\n if row is not None:\\n valid_eid = row[0]\\n else:\\n raise KeyError((\\\"Gene ID %s from source %s was not found \\\" + \\\\\\n \\\"in the database\\\") % (gene_id, source))\\n\\n if valid_eid is None:\\n raise KeyError(\\\"Unable to find a valid Entrez ID for %s from %s\\\" % (gene_id, source))\\n\\n valid_eid = int(valid_eid)\\n if source not in self.source_cache:\\n self.source_cache[source] = {}\\n self.source_cache[source][gene_id] = valid_eid\\n self.gene_cache[valid_eid] = Gene(valid_eid, self)\\n\\n return self.gene_cache[valid_eid]\",\n \"def get_gene_ids():\\n key = ('materialized', 'hugo')\\n if data.exists(*key):\\n return data.load(*key)\\n d = hugo.get_huge_genes()\\n d = d[~d['Approved Name'].str.lower().str.contains('symbol withdrawn|entry withdrawn')]\\n d = d['Approved Symbol'].unique()\\n data.save(*key, d)\\n return d\",\n \"def test_gxd_simple(self):\\n \\n gxd = get_gxd(gxd_file, self.emapa, (0.5, 0.05)) \\n \\n # check ids\\n self.assertEqual(len(gxd), 3, \\\"three models/markers\\\")\\n self.assertEqual(gxd[\\\"MA:010\\\"].id, \\\"GXD_MA:010\\\")\\n self.assertEqual(gxd[\\\"MA:011\\\"].id, \\\"GXD_MA:011\\\")\\n self.assertEqual(gxd[\\\"MA:009\\\"].id, \\\"GXD_MA:009\\\")\\n \\n # check markers\\n self.assertEqual(gxd[\\\"MA:010\\\"].description[\\\"marker_id\\\"], \\\"MA:010\\\")\\n self.assertEqual(gxd[\\\"MA:011\\\"].description[\\\"marker_id\\\"], \\\"MA:011\\\")\\n self.assertEqual(gxd[\\\"MA:009\\\"].description[\\\"marker_id\\\"], \\\"MA:009\\\")\\n \\n # check parsing and consensus for phenotype \\n self.assertEqual(len(gxd[\\\"MA:010\\\"].data), 1, \\\"1+\\\")\\n self.assertEqual(len(gxd[\\\"MA:011\\\"].data), 2, \\\"1+, 1- phenotypes\\\")\\n self.assertEqual(len(gxd[\\\"MA:009\\\"].data), 1, \\\"1+ after consensus\\\")\\n \\n # MA:009 should be averaged over assay, weighted by strength\\n # i.e. value 1, tpr_raw*(2/3)\\n datum = gxd[\\\"MA:009\\\"].data[0]\\n self.assertEqual(datum.value, 1, \\\"overall should be detected\\\") \\n self.assertEqual(datum.tpr, (0.05 + (0.5-0.05)*0.25)*2/3)\\n self.assertEqual(datum.fpr, 0.05)\\n \\n # MA:010 should be average (Strong, Not specified), weighted by strength only\\n datum = gxd[\\\"MA:010\\\"].data[0]\\n self.assertEqual(datum.value, 1, \\\"overall is detected\\\")\\n self.assertEqual(datum.tpr, 0.05 + (0.5-0.05)*0.75)\\n self.assertEqual(datum.fpr, 0.05)\",\n \"def load_gene_data_from_file(self) -> None:\\n logger.info(\\\"Loading genes data from file\\\")\\n if not self.gene_data or len(self.gene_data.items()) == 0:\\n self.gene_data = {}\\n file_path = self._get_cached_file(cache_path=self.gene_data_cache_path, file_source_url=self.gene_data_url)\\n with open(file_path) as file:\\n for line in file:\\n fields = line.strip().split(',')\\n if fields[1].startswith(\\\"WBGene\\\"):\\n name = fields[2] if fields[2] != '' else fields[3]\\n self.gene_data[\\\"WB:\\\" + fields[1]] = Gene(\\\"WB:\\\" + fields[1], name, fields[4] == \\\"Dead\\\", False)\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def get_data():\\n pass\",\n \"def next_gene(self):\\n pass\",\n \"def tcga_read_data():\\n print(\\\"Downloading data ...\\\")\\n try:\\n os.mkdir(cache_directory)\\n except FileExistsError:\\n pass\\n \\n brca_path= os.path.join(cache_directory, expression_matrix_name + \\\".tsv.gz\\\")\\n brca_clin_path = os.path.join(cache_directory, phenotype_name + \\\".tsv.gz\\\")\\n try:\\n brca = pd.read_csv(brca_path, sep=\\\"\\\\t\\\",index_col=0)\\n brca_clin = pd.read_csv(brca_clin_path, sep=\\\"\\\\t\\\",index_col=0)\\n return brca, brca_clin\\n except:\\n pass\\n\\n # Download TCGA data\\n tcga_path = os.path.join(cache_directory, tcga_name + \\\".tar.gz\\\")\\n download_file_if_not_present(tcga_url, tcga_path)\\n print(\\\"Tar-file inplace, extracting tables.\\\")\\n\\n # Decompress data into tables\\n tf = tarfile.open(tcga_path)\\n tf.extract(expression_name, cache_directory)\\n tf.extract(clinical_name, cache_directory)\\n\\n # def get_expression_data(self, path, file):\\n df = pd.read_csv(os.path.join(cache_directory, expression_name), sep=\\\"\\\\t\\\")\\n df.dropna(axis=0, how='any', inplace=True)\\n df.set_index('Entrez_Gene_Id', inplace=True)\\n # df.drop(columns=['Unnamed: 0', 'Entrez_Gene_Id'], inplace=True)\\n # df.drop(columns=['Entrez_Gene_Id'], inplace=True)\\n df.drop(columns=['Hugo_Symbol'], inplace=True)\\n brca = df.reindex(sorted(df.columns), axis=1)\\n\\n # get_clinical_data(brca_clin_path,\\\"data_clinical_sample.txt\\\")\\n df = pd.read_csv(os.path.join(cache_directory, clinical_name), sep=\\\"\\\\t\\\").T\\n df.columns = df.loc[\\\"Sample Identifier\\\"]\\n df.drop(columns=[\\\"A unique sample identifier.\\\",\\\"STRING\\\",\\\"1\\\",\\\"SAMPLE_ID\\\"], inplace=True,errors='ignore')\\n if 'TCGA-BH-A1ES-01' in df.columns:\\n df.drop(columns=['TCGA-BH-A1ES-01'], inplace=True)\\n df.drop(index=[\\\"Unnamed: 0\\\",\\\"#Patient Identifier\\\",\\\"Sample Identifier\\\",\\\"Other Sample ID\\\"], inplace=True,errors='ignore')\\n brca_clin = df.reindex(sorted(df.columns), axis=1)\\n\\n brca_clin, brca_clin = tcga_tn_preprocess(brca, brca_clin)\\n\\n # Put the extracted matrixes to the file cashe, so we do not have to do this again if procedure is repeated.\\n brca.to_csv(brca_path, sep=\\\"\\\\t\\\")\\n brca_clin.to_csv(brca_clin_path, sep=\\\"\\\\t\\\")\\n return brca, brca_clin\",\n \"def test_get_genome_8(self):\\n self.tkt1.data_add = set([\\\"accession\\\"])\\n gnm = tickets.get_genome(self.tkt1, gnm_type=\\\"add\\\")\\n with self.subTest():\\n self.assertEqual(gnm.host_genus, \\\"\\\")\\n with self.subTest():\\n self.assertEqual(gnm.accession, \\\"ABC123\\\")\",\n \"def sample_meta(self):\\n return self._data.iloc[:, self.n_genes :]\",\n \"def get_aggregation_popensity_df():\\n df = pandas.read_csv(fixpath('DnaK_reactions_parameters_5.csv'))\\n\\n return df.set_index('gene')\",\n \"def get_data():\\n if not hasattr(g, 'data'):\\n g.data = load_data()\\n return g.data\",\n \"def test_get_g_data_1(self):\\n self.db_filter.values = [40481]\\n\\n g_data = review.get_g_data(self.alchemist, self.db_filter, 40481)\\n\\n self.assertTrue(isinstance(g_data, list))\\n\\n for header in review.PG_HEADER:\\n with self.subTest(header=header):\\n self.assertTrue(header in g_data[0].keys())\\n self.assertFalse(isinstance(g_data[0][header], list))\",\n \"def retrieve_genome_data(filepath):\\n try:\\n seqrecords = list(SeqIO.parse(filepath, \\\"genbank\\\"))\\n except:\\n seqrecords = []\\n # filename = filepath.split(\\\"/\\\")[-1]\\n if len(seqrecords) == 0:\\n print(f\\\"There are no records in {filepath.name}.\\\")\\n seqrecord = None\\n elif len(seqrecords) > 1:\\n print(f\\\"There are multiple records in {filepath.name}.\\\" )\\n seqrecord = None\\n else:\\n seqrecord = seqrecords[0]\\n return seqrecord\",\n \"def test_get_genome_1(self):\\n self.tkt1.data_add = set([\\\"\\\"])\\n gnm = tickets.get_genome(self.tkt1, gnm_type=\\\"add\\\")\\n with self.subTest():\\n self.assertEqual(gnm.id, \\\"Trixie\\\")\\n with self.subTest():\\n self.assertEqual(gnm.name, \\\"Trixie_Draft\\\")\\n with self.subTest():\\n self.assertEqual(gnm.type, \\\"add\\\")\\n with self.subTest():\\n self.assertEqual(gnm.host_genus, \\\"\\\")\\n with self.subTest():\\n self.assertEqual(gnm.cluster, \\\"\\\")\\n with self.subTest():\\n self.assertEqual(gnm.subcluster, \\\"\\\")\\n with self.subTest():\\n self.assertEqual(gnm.annotation_status, \\\"\\\")\\n with self.subTest():\\n self.assertEqual(gnm.annotation_author, -1)\\n with self.subTest():\\n self.assertEqual(gnm.retrieve_record, -1)\\n with self.subTest():\\n self.assertEqual(gnm.accession, \\\"\\\")\",\n \"def data_from_result():\\n return dict(\\n gene=\\\"BRAF\\\",\\n strand=\\\"-\\\",\\n tx_pos_range=(1802, 1921),\\n alt_pos_range=(140453074, 140453193),\\n alt_aln_method=\\\"splign\\\",\\n tx_exon_id=780494,\\n alt_exon_id=1927263\\n )\",\n \"def GetGeneName(arg):\\n\\n genbank = ChromUnzip(arg)\\n \\n p1=re.compile(r'(?:ACCESSION\\\\s+)(\\\\w+\\\\d+)')\\n p6=re.compile(r'(?:/gene=\\\")(.+?)(?:\\\"\\\\s+)')\\n\\n gene_name_dict={}\\n \\n for entry in genbank:\\n gene_list=[] \\n gene_it_6=p6.finditer(entry)\\n gene_it_1=p1.finditer(entry) \\n for hit in gene_it_6:\\n gene_list.append(hit.group(1))\\n for item in gene_it_1:\\n gene_name_dict[item.group(1)]=gene_list[0]\\n \\n return gene_name_dict\",\n \"def generate_gene_set_data(\\n data,\\n genes,\\n gene_name_type=\\\"entrez\\\",\\n gene_set_category=\\\"c6.all\\\",\\n metric=\\\"mean\\\",\\n standardize=False,\\n data_dir=\\\"../../Data/examples/Gene_Sets/MSigDB.v7.0/\\\",\\n):\\n\\n sample_name = None\\n if isinstance(data, pd.DataFrame):\\n sample_name = data.index\\n data = data.values\\n elif not isinstance(data, np.ndarray):\\n print(\\\"Input data must be a numpy array or pandas data frame\\\")\\n sys.exit(1)\\n\\n if standardize:\\n scaler = StandardScaler()\\n data = scaler.fit_transform(data)\\n\\n genes = [str(i) for i in genes]\\n\\n if gene_name_type == \\\"entrez\\\":\\n gene_set_category = gene_set_category + \\\".v7.0.entrez.gmt\\\"\\n if gene_name_type == \\\"symbols\\\":\\n gene_set_category = gene_set_category + \\\".v7.0.symbols.gmt\\\"\\n f = open(data_dir + gene_set_category, \\\"r\\\")\\n x = f.readlines()\\n gene_sets = {}\\n for i in range(len(x)):\\n temp = x[i].split(\\\"\\\\n\\\")[0].split(\\\"\\\\t\\\")\\n gene_sets[temp[0]] = temp[2:]\\n\\n gene_set_data = np.empty((data.shape[0], len(gene_sets)))\\n gene_set_data.fill(np.nan)\\n gene_set_names = np.array(list(gene_sets.keys()))\\n for i in range(len(gene_set_names)):\\n idi = np.where(np.isin(genes, gene_sets[gene_set_names[i]]))[0]\\n if len(idi) > 0:\\n if metric == \\\"sum\\\":\\n gene_set_data[:, i] = np.nansum(data[:, idi], axis=1)\\n elif metric == \\\"max\\\":\\n gene_set_data[:, i] = np.nanmax(data[:, idi], axis=1)\\n elif metric == \\\"min\\\":\\n gene_set_data[:, i] = np.nanmin(data[:, idi], axis=1)\\n elif metric == \\\"abs_mean\\\":\\n gene_set_data[:, i] = np.nanmean(np.absolute(data[:, idi]), axis=1)\\n elif metric == \\\"abs_maximum\\\":\\n gene_set_data[:, i] = np.nanmax(np.absolute(data[:, idi]), axis=1)\\n else: # 'mean'\\n gene_set_data[:, i] = np.nanmean(data[:, idi], axis=1)\\n\\n if sample_name is None:\\n gene_set_data = pd.DataFrame(gene_set_data, columns=gene_set_names)\\n else:\\n gene_set_data = pd.DataFrame(\\n gene_set_data, columns=gene_set_names, index=sample_name\\n )\\n keep_id = np.where(np.sum(np.invert(pd.isna(gene_set_data)), axis=0) > 0)[0]\\n gene_set_data = gene_set_data.iloc[:, keep_id]\\n\\n return gene_set_data\",\n \"def get_gga_data(port):\\n \\n \\n # Wait for GGA message :\\n gga = port.readline().decode(\\\"utf-8\\\")\\n while not 'GGA' in gga:\\n if gga: print(\\\"Wait for GGA : \\\", gga)\\n gga = port.readline().decode(\\\"utf-8\\\")\\n \\n \\n t = np.float(gga[7:16])\\n \\n # Print messages :\\n print(\\\"Heading antenna frame :\\\")\\n print(\\\" GGA: \\\",gga)\\n \\n # Quality check :\\n if not 'GGA' in gga:\\n print(\\\"Issue with GGA frame decoding !\\\\nMessage:\\\\nGGA:{0}\\\\n\\\".format(gga))\\n gga, t = get_gga_data(port)\\n \\n return gga, t\",\n \"def get_genes(request, genome, chrom, start, end):\\n logger.debug(\\\"annotation_server.get_genes called for genome: %s chromosome: %s\\\" % (genome, chrom)) \\n \\n if genome in SUPPORTED_GENOMES:\\n current_table = eval(genome+ \\\"_EnsGene\\\")\\n curr_vals = current_table.objects.filter(\\n Q(chrom__iexact=chrom),\\n Q(cdsStart__range=(start, end)) | Q(cdsEnd__range=(start, end))\\n ).values('name', 'chrom', 'strand', 'txStart', 'txEnd', 'cdsStart', 'cdsEnd', 'exonCount', 'exonStarts', 'exonEnds')\\n data = ValuesQuerySetToDict(curr_vals)\\n return HttpResponse(data, 'application/json')\\n else:\\n return HttpResponse(status=400)\\n \\n \\n # Postbio query\\n #cursor = connection.cursor() \\n #query = \\\"\\\"\\\"SELECT x.symbol, r.name, #<r.region as start, #>r.region as end, case when r.same_orient then '+' else '-' end as strand, #<r.cds as cds_start, #>r.cds as cds_end from dm3.flybase r join dm3.flyBase2004Xref x on r.name = x.name JOIN (select id, name from dm3.sequence where name = '%s') n ON n.id = r.seq_id and region && int_interval '(%s,%s)' order by region\\\"\\\"\\\" % (chrom, start, end)\\n #cursor.execute(query) \\n #return HttpResponse(cursor_to_json(cursor), 'application/javascript')\",\n \"def data_estagio(self):\\n return self._data_estagio\",\n \"def get_data(self):\\n pass\",\n \"def get_data(self):\\n pass\",\n \"def extract_data( file_name):\\n\\n main_file = fits.open( file_name)\\n\\n ssp = main_file[1].data\\n flux_elines = main_file[3].data\\n org_hdr = main_file[0].header\\n\\n main_file.close()\\n\\n ###########################################################################\\n # NOTE: The visual band fluxes are multiplied by 10^-16 as stated in the\\n # units of the MaNGA Data Model.\\n #\\n # <https://data.sdss.org/datamodel/files/MANGA_PIPE3D/MANGADRP_VER\\n # /PIPE3D_VER/PLATE/manga.Pipe3D.cube.html#hdu1>\\n ###########################################################################\\n v_band = ssp[0] # in units of erg / s / cm^2\\n v_band_err = ssp[4] # in units of erg / s / cm^2\\n sMass_density = ssp[19] * u.dex( u.M_sun) # in units of log10( Msun / spaxel**2)\\n\\n Ha_vel = flux_elines[102] # in units of km/s\\n Ha_vel_err = flux_elines[330] # in units of km/s\\n\\n gal_ra = org_hdr['OBJRA']\\n gal_dec = org_hdr['OBJDEC']\\n\\n target_galaxy = True\\n MaNGA_galaxy_target = org_hdr['MNGTARG1']\\n if MaNGA_galaxy_target == 0:\\n target_galaxy = False\\n\\n data_quality = True\\n DRP_3D_quality = org_hdr['DRP3QUAL']\\n if DRP_3D_quality > 10000:\\n data_quality = False\\n\\n return target_galaxy, data_quality, Ha_vel, Ha_vel_err, v_band, v_band_err, \\\\\\n sMass_density, gal_ra, gal_dec\",\n \"def genes():\\n data=pd.read_csv(config['stan'], sep=\\\" \\\")\\n return list(set(data['Gene_id']))\",\n \"async def test_mane_c_genomic_data(test_db):\\n resp = await test_db.get_mane_c_genomic_data(\\n \\\"NM_001374258.1\\\", None, 140753335, 140753335\\n )\\n expected = dict(\\n gene=\\\"BRAF\\\",\\n strand=\\\"-\\\",\\n tx_pos_range=(2087, 2206),\\n alt_pos_range=(140753274, 140753393),\\n alt_aln_method=\\\"splign\\\",\\n tx_exon_id=8439617,\\n alt_exon_id=9353476,\\n coding_start_site=226,\\n coding_end_site=2650,\\n alt_pos_change=(57, 62),\\n alt_pos_change_range=(140753336, 140753336),\\n tx_ac=\\\"NM_001374258.1\\\",\\n alt_ac=\\\"NC_000007.14\\\"\\n )\\n assert resp == expected\",\n \"def gatherData(data,neat,gen,iter_i,hyp,savePop=False):\\n data.gatherData(neat.pop, neat.species)\\n\\n if savePop is True: # Get a sample pop to play with in notebooks\\n global fileName\\n pref = output_dir + '/iter_{}'.format(iter_i) + '/gen_' + str(gen).zfill(4)\\n import pickle\\n with open(pref+'.obj', 'wb') as fp:\\n pickle.dump(neat.pop,fp)\\n\\n return data\",\n \"def LoadEEGData(filename, EEGdevice):\\n if EEGdevice == 7:\\n x = 1\\n elif EEGdevice == 8:\\n # Read in the .easy file\\n df = pd.read_csv(filename, delimiter='\\\\t', header=None)\\n\\n # Get metadata from the .info file\\n fname = filename[:-5] + '.info'\\n with open(fname) as f:\\n content = f.readlines()\\n content = [x.strip() for x in content]\\n\\n # Get the channel names\\n channel_info = [x for x in content if 'Channel ' in x]\\n channel_names = []\\n for ch in range(len(channel_info)):\\n channel_names.append(channel_info[ch].split(': ')[1])\\n\\n channel_names.append('X')\\n channel_names.append('Y')\\n channel_names.append('Z')\\n channel_names.append('STI 014')\\n channel_names.append('DateTime')\\n\\n # Get sampling rates\\n sampling_rates = [x for x in content if 'sampling rate: ' in x]\\n fs_all = []\\n for freq in range(len(sampling_rates)):\\n tmp = sampling_rates[freq].split(': ')[1].split(' ')[0]\\n if tmp in ['N/A']:\\n print('Skipping N/A')\\n else:\\n fs_all.append(float(sampling_rates[freq].split(': ')[1].split(' ')[0]))\\n\\n # Store sampling rates\\n fs = fs_all[0]\\n fs_accel = fs_all[1]\\n\\n # Assign the column names\\n df.columns = channel_names\\n \\n # Return dataframe and sampling rates\\n return df, fs, fs_accel\",\n \"def load_data_gse68465(verbose=-1, read_as_ndarray=False):\\n clinical, genes, outcome = load_data_gse('GSE68465', processing_gse68465, verbose, read_as_ndarray)\\n\\n return clinical, genes, outcome\",\n \"def extract_gene_args(self, line):\\n result = {'seq_name': line[0], 'source': line[1], \\\\\\n 'indices': [int(line[3]), int(line[4])], 'strand': line[6]}\\n attribs = self.parse_attributes(line[8])\\n\\n if not attribs:\\n return None\\n\\n result.update(attribs)\\n return result\",\n \"def test_get_genome_6(self):\\n self.tkt1.data_add = set([\\\"annotation_author\\\"])\\n gnm = tickets.get_genome(self.tkt1, gnm_type=\\\"add\\\")\\n with self.subTest():\\n self.assertEqual(gnm.host_genus, \\\"\\\")\\n with self.subTest():\\n self.assertEqual(gnm.annotation_author, 1)\",\n \"def isgene(s, gene):\\n test = s.query(Genes).filter(Genes.name.ilike(gene)).first()\\n if test is None:\\n gene_list = check_gene_name(gene)\\n if len(gene_list) == 0:\\n return None\\n else:\\n for g in gene_list:\\n print(g)\\n test = s.query(Genes).filter(Genes.name.ilike(str(g))).first()\\n if test is not None:\\n return test.name\\n return None\\n else:\\n return test.name\",\n \"def get_data(self):\\r\\n pass\",\n \"def read_dataset_v2():\\n path = load_config()\\n T = feather.read_dataframe(path['data_dir'] / 'T_dat_v2.feather')\\n E = feather.read_dataframe(path['data_dir'] / 'E_dat_v2.feather')\\n M = feather.read_dataframe(path['data_dir'] / 'Meta_v2.feather')\\n data = sio.loadmat(path['data_dir'] / 'highvar_genes_v2.mat', squeeze_me=True)\\n return T, E, M, data\",\n \"def testEnsemblToGeneFile(self):\\n\\n e2g = EnsemblToGeneFile(self.enstogenefile)\\n\\n self.assertTrue(e2g)\\n\\n self.assertTrue(len(e2g.geneids) == 38803)\\n self.assertTrue(len(e2g.tranids) == 94647)\",\n \"def __getitem__(self, key: str) -> float64:\\n\\n # extract the gene\\n geno_id, allele_variant = geno_to_idx(key)\\n\\n return self._store[geno_id][allele_variant]\",\n \"def get_mult_gene_RNA(ensemble, genes, grouping, max_points='10000'):\\n\\n\\t# Prevent SQL injected since column names cannot be parameterized.\\n\\tif \\\";\\\" in ensemble or \\\";\\\" in grouping:\\n\\t\\treturn None\\n\\n\\tgenes = [gene+\\\"%\\\" for gene in genes]\\n\\n\\t# This query is just to fix gene id's missing the ensemble version number.\\n\\t# Necessary because the table name must match exactly with whats on the MySQL database.\\n\\t# Ex. ENSMUSG00000026787 is fixed to ENSMUSG00000026787.3\\n\\tfirst_query = \\\"SELECT gene_id FROM genes WHERE gene_id LIKE %s\\\" + \\\" OR gene_id LIKE %s\\\" * (len(genes)-1)\\n\\tresult = db.get_engine(current_app, 'methylation_data').execute(first_query, (genes,)).fetchall()\\n\\n\\tgene_table_names = ['gene_' + gene_id[0].replace('.','_') for gene_id in result]\\n\\n\\tdf_all = pd.DataFrame()\\n\\n\\tfirst = True\\n\\tfor gene_table_name in gene_table_names:\\n\\t\\tquery = \\\"SELECT cells.cell_id, cells.cell_name, cells.dataset, \\\\\\n\\t\\t\\t%(ensemble)s.annotation_RNA, %(ensemble)s.cluster_RNA, \\\\\\n\\t\\t\\t%(ensemble)s.tsne_x_RNA, %(ensemble)s.tsne_y_RNA, \\\\\\n\\t\\t\\t%(gene_table_name)s.normalized_counts, \\\\\\n\\t\\t\\tdatasets.target_region \\\\\\n\\t\\t\\tFROM cells \\\\\\n\\t\\t\\tINNER JOIN %(ensemble)s ON cells.cell_id = %(ensemble)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN %(gene_table_name)s ON %(ensemble)s.cell_id = %(gene_table_name)s.cell_id \\\\\\n\\t\\t\\tLEFT JOIN datasets ON cells.dataset = datasets.dataset\\\" % {'ensemble': ensemble,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t 'gene_table_name': gene_table_name}\\n\\t\\tif max_points.isdigit():\\n\\t\\t\\tquery = query+\\\" ORDER BY RAND() LIMIT %(max_points)s()\\\" % {'max_points': max_points}\\n\\n\\t\\ttry:\\n\\t\\t\\tdf_all = df_all.append(pd.read_sql(query, db.get_engine(current_app, 'RNA_data')))\\n\\t\\texcept exc.ProgrammingError as e:\\n\\t\\t\\tnow = datetime.datetime.now()\\n\\t\\t\\tprint(\\\"[{}] ERROR in app(get_mult_gene_RNA): {}\\\".format(str(now), e))\\n\\t\\t\\tsys.stdout.flush()\\n\\t\\t\\treturn None\\n\\n\\t\\tif first:\\n\\t\\t\\tdf_coords = df_all\\n\\t\\tfirst = False\\n\\n\\tif df_all.empty: # If no data in column, return None\\n\\t\\tnow = datetime.datetime.now()\\n\\t\\tprint(\\\"[{}] ERROR in app(get_gene_RNA): No RNA data for {}\\\".format(str(now), ensemble))\\n\\t\\tsys.stdout.flush()\\n\\t\\treturn None\\n\\n\\tdf_all['normalized_counts'].fillna(0, inplace=True)\\n\\n\\tdf_avg_methylation = df_all.groupby(by='cell_id', as_index=False)['normalized_counts'].mean()\\n\\tdf_coords.update(df_avg_methylation)\\n\\n\\tif grouping == 'annotation':\\n\\t\\tdf_coords.fillna({'annotation_RNA': 'None'}, inplace=True)\\n\\t\\tdf_coords['annotation_cat'] = pd.Categorical(df_coords['annotation_RNA'], cluster_annotation_order)\\n\\t\\tdf_coords.sort_values(by='annotation_cat', inplace=True)\\n\\t\\tdf_coords.drop('annotation_cat', axis=1, inplace=True)\\n\\telif grouping == 'cluster':\\n\\t\\tdf_coords.sort_values(by='cluster_RNA', inplace=True)\\n\\treturn df_coords\",\n \"def get_aa (tRNA):\\n\\tpass\",\n \"def gene_search(\\n self,\\n genes:list=[\\\"MYL2\\\"], \\n ):\\n try: \\n assert isinstance(genes, list)\\n except AssertionError as e:\\n e.args += (\\\"[genes] argument needs to be type(list)\\\", )\\n raise\\n \\n\\n self.genes = genes\\n\\n self.requestURL = f\\\"https://www.ebi.ac.uk/proteins/api/proteins?offset=0&size=100&gene={'%2C%20'.join(genes)}&organism=human\\\"\\n \\n r = requests.get(self.requestURL, headers={ \\\"Accept\\\" : \\\"application/json\\\"})\\n \\n if not r.ok:\\n r.raise_for_status()\\n sys.exit()\\n\\n self.responseBody = r.text\\n self.data = json.loads(self.responseBody)\\n\\n return self.responseBody\",\n \"def evaluate(self,gene):\\n return prng.choice(gene.allele_set)\",\n \"def adata():\\n return AnnData(\\n X=np.ones((2, 2)),\\n obs=pd.DataFrame(\\n {\\\"obs1\\\": [0, 1], \\\"obs2\\\": [\\\"a\\\", \\\"b\\\"]}, index=[\\\"cell1\\\", \\\"cell2\\\"]\\n ),\\n var=pd.DataFrame(\\n {\\\"gene_symbols\\\": [\\\"genesymbol1\\\", \\\"genesymbol2\\\"]}, index=[\\\"gene1\\\", \\\"gene2\\\"]\\n ),\\n layers={\\\"double\\\": sparse.csr_matrix(np.ones((2, 2)), dtype=int) * 2},\\n dtype=int,\\n )\",\n \"def parseGGA(data):\\n #print \\\"GGA received\\\"\\n # print data\\n return pack([\\\"utc\\\", \\\"lat\\\", \\\"ns\\\", \\\"lon\\\", \\\"ew\\\", \\\"quality\\\"\\n \\\"numSats\\\", \\\"horizontalDilution\\\", \\\"altitude\\\",\\n \\\"altitudeUnits\\\", \\\"separation\\\", \\\"separationUnits\\\",\\n \\\"age\\\", \\\"reference\\\"],\\n data)\",\n \"def queryYM( self, geneName, level ):\\n result = [] \\n \\n # Get a new query on the table\\n query = service.new_query(\\\"Gene\\\")\\n query.add_constraint(\\\"interactions.participant2\\\", \\\"Gene\\\") \\n \\n query.add_view( \\\"primaryIdentifier\\\", \\\"symbol\\\", \\\"secondaryIdentifier\\\", \\\"sgdAlias\\\", \\\"name\\\",\\n \\\"organism.shortName\\\", \\\"interactions.details.annotationType\\\",\\n \\\"interactions.details.phenotype\\\", \\\"interactions.details.role1\\\",\\n \\\"interactions.details.experimentType\\\", \\\"interactions.participant2.symbol\\\",\\n \\\"interactions.participant2.secondaryIdentifier\\\",\\n \\\"interactions.details.experiment.name\\\",\\n \\\"interactions.details.relationshipType\\\" )\\n \\n query.add_constraint(\\\"organism.shortName\\\", \\\"=\\\", \\\"S. cerevisiae\\\", code = \\\"B\\\")\\n query.add_constraint(\\\"Gene\\\", \\\"LOOKUP\\\", geneName, code = \\\"A\\\")\\n \\n for row in query.rows():\\n data = level, row[\\\"primaryIdentifier\\\"], row[\\\"symbol\\\"], row[\\\"secondaryIdentifier\\\"], row[\\\"sgdAlias\\\"], \\\\\\n row[\\\"name\\\"], row[\\\"organism.shortName\\\"], row[\\\"interactions.details.annotationType\\\"], \\\\\\n row[\\\"interactions.details.phenotype\\\"], row[\\\"interactions.details.role1\\\"], \\\\\\n row[\\\"interactions.details.experimentType\\\"], row[\\\"interactions.participant2.symbol\\\"], \\\\\\n row[\\\"interactions.participant2.secondaryIdentifier\\\"], \\\\\\n row[\\\"interactions.details.experiment.name\\\"], row[\\\"interactions.details.relationshipType\\\"]\\n item = list(data)\\n result.append(item) \\n \\n return result\",\n \"def getGeneList( self ):\\n return self.geneList\",\n \"def test_get_genome_2(self):\\n self.tkt1.data_add = set([\\\"host_genus\\\"])\\n gnm = tickets.get_genome(self.tkt1, gnm_type=\\\"add\\\")\\n with self.subTest():\\n self.assertEqual(gnm.host_genus, \\\"Mycobacterium\\\")\\n with self.subTest():\\n self.assertEqual(gnm.cluster, \\\"\\\")\",\n \"def _get_all_oshapes(self):\\n an_iname = self.node_list[0]\\n an_inode = self.builder.nodes[an_iname]\\n an_ishape = an_inode.oshapes['loc']\\n \\n return {'main' : an_ishape,\\n 'loc' : an_ishape,\\n 'cov' : an_ishape + [an_ishape[-1]]}\",\n \"def download_data(self) -> None: # coverage: ignore\\n\\n navaids = []\\n c = requests.get(f\\\"{base_url}/earth_fix.dat\\\")\\n\\n for line in c.iter_lines():\\n\\n line = line.decode(encoding=\\\"ascii\\\", errors=\\\"ignore\\\").strip()\\n\\n # Skip empty lines or comments\\n if len(line) < 3 or line[0] == \\\"#\\\":\\n continue\\n\\n # Start with valid 2 digit latitude -45. or 52.\\n if not ((line[0] == \\\"-\\\" and line[3] == \\\".\\\") or line[2] == \\\".\\\"):\\n continue\\n\\n # Data line => Process fields of this record, separated by a comma\\n # Example line:\\n # 30.580372 -094.384169 FAREL\\n fields = line.split()\\n navaids.append(\\n Navaid(\\n fields[2],\\n \\\"FIX\\\",\\n float(fields[0]),\\n float(fields[1]),\\n None,\\n None,\\n None,\\n None,\\n )\\n )\\n\\n c = requests.get(f\\\"{base_url}/earth_nav.dat\\\")\\n\\n for line in c.iter_lines():\\n\\n line = line.decode(encoding=\\\"ascii\\\", errors=\\\"ignore\\\").strip()\\n\\n # Skip empty lines or comments\\n if len(line) == 0 or line[0] == \\\"#\\\":\\n continue\\n\\n # Data line => Process fields of this record, separated by a comma\\n # Example lines:\\n # 2 58.61466599 125.42666626 451 522 30 0.0 A Aldan NDB\\n # 3 31.26894444 -085.72630556 334 11120 40 -3.0 OZR CAIRNS VOR-DME\\n # type lat lon elev freq ? var id desc\\n # 0 1 2 3 4 5 6 7 8\\n\\n fields = line.split()\\n\\n # Valid line starts with integers\\n if not fields[0].isdigit():\\n continue # Next line\\n\\n # Get code for type of navaid\\n itype = int(fields[0])\\n\\n # Type names\\n wptypedict = {\\n 2: \\\"NDB\\\",\\n 3: \\\"VOR\\\",\\n 4: \\\"ILS\\\",\\n 5: \\\"LOC\\\",\\n 6: \\\"GS\\\",\\n 7: \\\"OM\\\",\\n 8: \\\"MM\\\",\\n 9: \\\"IM\\\",\\n 12: \\\"DME\\\",\\n 13: \\\"TACAN\\\",\\n }\\n\\n # Type code never larger than 20\\n if itype not in list(wptypedict.keys()):\\n continue # Next line\\n\\n wptype = wptypedict[itype]\\n\\n # Select types to read\\n if wptype not in [\\\"NDB\\\", \\\"VOR\\\", \\\"ILS\\\", \\\"GS\\\", \\\"DME\\\", \\\"TACAN\\\"]:\\n continue # Next line\\n\\n # Find description\\n try:\\n idesc = line.index(fields[7]) + len(fields[7])\\n description: Optional[str] = line[idesc:].strip().upper()\\n except Exception:\\n description = None\\n\\n navaids.append(\\n Navaid(\\n fields[7],\\n wptype,\\n float(fields[1]),\\n float(fields[2]),\\n float(fields[3][1:])\\n if fields[3].startswith(\\\"0-\\\")\\n else float(fields[3]),\\n float(fields[4])\\n if wptype == \\\"NDB\\\"\\n else float(fields[4]) / 100,\\n float(fields[6])\\n if wptype in [\\\"VOR\\\", \\\"NDB\\\", \\\"ILS\\\", \\\"GS\\\"]\\n else None,\\n description,\\n )\\n )\\n\\n self._data = pd.DataFrame.from_records(\\n navaids, columns=NavaidTuple._fields\\n )\\n\\n self._data.to_pickle(self.cache_dir / \\\"traffic_navaid.pkl\\\")\",\n \"def extract_genes(seq_record):\\n return [f for f in seq_record.features if f.type == \\\"gene\\\"]\",\n \"def geneactivity(adata,\\n gtf_file,\\n key_added='gene',\\n upstream=5000,\\n feature_type='gene',\\n annotation='HAVANA',\\n layer_name='geneactivity',\\n raw=False, \\n copy=True):\\n ### extracting the genes\\n gtf = {}\\n with open(gtf_file) as f:\\n for line in f:\\n if line[0:2] != '##' and '\\\\t'+feature_type+'\\\\t' in line and '\\\\t'+annotation+'\\\\t' in line:\\n line = line.rstrip('\\\\n').split('\\\\t')\\n if line[6] == '-':\\n if line[0] not in gtf.keys():\\n gtf[line[0]] = [[int(line[3]), int(line[4])+upstream,line[-1].split(';')[:-1]]]\\n else:\\n gtf[line[0]].append([int(line[3]), int(line[4])+upstream,line[-1].split(';')[:-1]])\\n else:\\n if line[0] not in gtf.keys():\\n gtf[line[0]] = [[int(line[3])-upstream, int(line[4]),line[-1].split(';')[:-1]]]\\n else:\\n gtf[line[0]].append([int(line[3])-upstream, int(line[4]),line[-1].split(';')[:-1]])\\n\\n # extracting the feature coordinates\\n if raw==True:\\n raw_adata = adata.raw.to_adata()\\n else:\\n raw_adata = adata.copy()\\n raw_adata_features = {}\\n feature_index = 0\\n for line in raw_adata.var_names.tolist():\\n line = line.split('_')\\n if line[0] not in raw_adata_features.keys():\\n raw_adata_features[line[0]] = [[int(line[1]),int(line[2]), feature_index]]\\n else:\\n raw_adata_features[line[0]].append([int(line[1]),int(line[2]), feature_index])\\n feature_index += 1\\n \\n ## find the features overlaping the genes. and build the count matrix\\n gene_index = []\\n gene_activity_X = []\\n \\n for chrom in gtf.keys():\\n if chrom in raw_adata_features.keys():\\n #print(chrom)\\n chrom_index = 0\\n previous_features_index = 0\\n for gene in gtf[chrom]:\\n gene_values = []\\n gene_start = gene[0]\\n gene_end = gene[1]\\n for feature in raw_adata_features[chrom]:\\n feature_index = 0\\n if (feature[1]<= gene_start): # the window is before the gene. we need to test the next window.\\n continue\\n elif (gene_end <= feature[0]): # the window is after the gene. we need totest the next gene.\\n break\\n else: # the window is overlapping the gene. \\n gene_values.append(raw_adata.X[:,feature[2]].todense())\\n if gene_values != []:\\n gene_activity_X.append(np.sum(gene_values, axis=0))\\n gene_index.append(gene[-1])\\n \\n\\n gene_activity_X = np.concatenate(tuple(gene_activity_X), axis=-1)\\n\\n # get the variable metadata\\n gene_name = []\\n if feature_type=='transcript':\\n for x in gene_index:\\n for y in x:\\n if 'transcript_name' in y:\\n gene_name.append(y.lstrip(' transcript_name \\\"').rstrip('\\\"'))\\n #gene_name = [x[7].lstrip(' transcript_name \\\"').rstrip('\\\"') for x in gene_index]\\n elif feature_type=='gene':\\n for x in gene_index:\\n for y in x:\\n if 'gene_name' in y:\\n gene_name.append(y.lstrip(' gene_name \\\"').rstrip('\\\"'))\\n #gene_name = [x[4].lstrip(' gene_name \\\"').rstrip('\\\"') for x in gene_index]\\n\\n metadata_genes = {'gene_id' : [],\\n 'transcript_id' : [],\\n 'gene_type' : [],\\n 'gene_name' : [],\\n 'transcript_type' : [],\\n 'transcript_name' : [],\\n 'protein_id' : []}\\n\\n for line in gene_index:\\n dico_line = {}\\n for element in line:\\n if ' \\\"' in element:\\n dico_line[element.rstrip('\\\"').lstrip(\\\" \\\").split(' \\\"')[0]] = element.rstrip('\\\"').lstrip(\\\" \\\").split(' \\\"')[1]\\n \\n for key in metadata_genes.keys():\\n if key in dico_line.keys():\\n metadata_genes[key].append(dico_line[key])\\n else:\\n metadata_genes[key].append('NA') \\n \\n dataframe_genes = pd.DataFrame.from_dict(metadata_genes)\\n dataframe_genes.index = gene_name\\n\\n #adata.layers[layer_name] = ad.AnnData(gene_activity_X, var=dataframe_genes, obs=raw_adata.obs)\\n gene_adata = ad.AnnData(gene_activity_X, var=dataframe_genes, obs=raw_adata.obs)\\n gene_adata.uns = adata.uns.copy()\\n gene_adata.obsm = adata.obsm.copy()\\n gene_adata.obsp = adata.obsp.copy()\\n return(gene_adata)\",\n \"def get_hilo_data():\\n # Get raw JSON data\\n magtag.url = get_data_source_url(hilo_only=True)\\n\\n return magtag.fetch()\",\n \"def get_data(dataset, **kwargs):\\n age_df = load_age_sample_from_mcmc_chains(dataset, **kwargs)\\n hr_df = load_hr()\\n age_df, hr_df = clean_data(age_df, hr_df)\\n snids = age_df.index.unique().tolist()\\n return snids, age_df, hr_df\",\n \"def gain_data_main():\\n gainfile = os.path.join(DATA_PATH, \\\"zen.2457698.40355.xx.gain.calfits\\\")\\n with uvtest.check_warnings(\\n UserWarning,\\n match=[\\n \\\"telescope_location is not set. Using known values for HERA.\\\",\\n \\\"antenna_positions are not set or are being overwritten. Using known \\\"\\n \\\"values for HERA.\\\",\\n ],\\n ):\\n gain_object = UVCal.from_file(gainfile, use_future_array_shapes=True)\\n gain_object.freq_range = None\\n\\n yield gain_object\\n\\n del gain_object\",\n \"def get_data():\\r\\n spatial_expmat = np.load('/home/anniegao/spatial_magan/data/spatial_pca_with_coords.npz')['arr_0']\\r\\n spatial_expmat[:,100:] *= 5\\r\\n rna_expmat = np.load('/home/anniegao/spatial_magan/data/rna_pca_sampled.npz')['arr_0']\\r\\n spatial_pca_components = np.load('/home/anniegao/spatial_magan/data/spatial_pca_100components.npz')['arr_0']\\r\\n rna_pca_components = np.load('/home/anniegao/spatial_magan/data/rna_pca_100components.npz')['arr_0']\\r\\n spatial_cluster_labels = np.load('/home/anniegao/spatial_magan/data/spatial_cluster_3_labels_phate.npz')['arr_0']\\r\\n rna_cluster_labels = np.load('/home/anniegao/spatial_magan/data/rna_cluster_5_labels_sampled.npz')['arr_0']\\r\\n return spatial_expmat, rna_expmat, spatial_pca_components, rna_pca_components, spatial_cluster_labels, rna_cluster_labels\",\n \"def get_expression(data_series, probes_to_genes):\\n with open(data_series, 'r') as mtx:\\n stage_columns = {'all_stages': {'sample_ids': []}} # will always need an average, other stages are determined by the file\\n sample_ids = None\\n for line in mtx:\\n if line.startswith('!Sample_title'):\\n sample_stages = [x.strip().replace('\\\"','').split(\\\",\\\")[0] for x in line.split(\\\"\\\\t\\\")[1:]] # this line is likely dataset specific.\\n elif line.startswith('\\\"ID_REF\\\"'): # this comes after the sample titles\\n sample_ids = [x.strip().replace('\\\"','') for x in line.split(\\\"\\\\t\\\")[1:]]\\n # now have the ids and their stages, convert to dict\\n \\\"\\\"\\\"\\n if named differently, may need to modify this.\\n ultimately, stage_columns should be a dictionary with the following properties:\\n - the keys are the stage names. \\n - each 'stage' dict should have a key 'sample_ids' that has a list the sample_ids belonging to that stage.\\n {\\n 'stage1': {\\n 'sample_ids': ['sample_id1','sample_id2', ..., 'sample_idn']\\n },\\n 'stage2': {\\n 'sample_ids': ['sample_idn+1', ...]\\n },\\n ...\\n }\\n \\\"\\\"\\\"\\n for i in range(0, len(sample_stages)):\\n if sample_stages[i] not in stage_columns:\\n stage_columns[sample_stages[i]] = {'sample_ids': []}\\n stage_columns[sample_stages[i]]['sample_ids'].append(sample_ids[i])\\n stage_columns['all_stages']['sample_ids'].append(sample_ids[i]) # add every sample to this\\n elif sample_ids is not None:\\n row = [x.strip().replace('\\\"','') for x in line.split('\\\\t')]\\n \\\"\\\"\\\"\\n here, the stage_columns dictionary is being updated with the expression data for each gene.\\n {\\n 'stage1': {\\n 'sample_ids': ['sample_id1','sample_id2', ..., 'sample_idn'],\\n 'genes': { <- **NEW KEY**\\n 'entrezID-1': ['sample_id1ExpLevel', 'sample_id2ExpLevel', ..., 'sample_idnExpLevel'],\\n 'entrezID-2': ['sample_id1ExpLevel', 'sample_id2ExpLevel', ..., 'sample_idnExpLevel'],\\n ... (if PERCENTILE_RANK is True, all in dataset are recorded otherwise, just the genes of interest )\\n }\\n },\\n ...\\n }\\n \\\"\\\"\\\"\\n if row[0] in probes_to_genes:\\n # get gene from probe\\n entrez_id = probes_to_genes[row[0]]\\n # add the average expression for all the samples in a stage for the gene\\n for stage, stage_data in stage_columns.items():\\n stage_data['genes'] = {} if 'genes' not in stage_data else stage_data['genes'] # initialize\\n for sample_id in stage_data['sample_ids']:\\n # get the index of the sample_id in the row\\n sample_idx = sample_ids.index(sample_id) + 1\\n if entrez_id not in stage_data['genes']:\\n stage_data['genes'][entrez_id] = [float(row[sample_idx])]\\n else:\\n stage_data['genes'][entrez_id].append(float(row[sample_idx]))\\n\\n return stage_columns\",\n \"def _get_probe():\\n probe_ds = tf.data.TFRecordDataset(\\n os.path.join(self.root, self.version, self.probe_folder,\\n 'imagenet2012-probe.tfrecord-1-of-1'))\\n probe_ds = probe_ds.map(\\n self.wrapper_map_probe_v2,\\n num_parallel_calls=tf.data.experimental.AUTOTUNE)\\n\\n # For single file, we need to disable auto_shard_policy for multi-workers,\\n # e.g. every worker takes the same file\\n options = tf.data.Options()\\n options.experimental_distribute.auto_shard_policy = (\\n tf.data.experimental.AutoShardPolicy.OFF)\\n probe_ds = probe_ds.with_options(options)\\n\\n return probe_ds\",\n \"def get_data(self, dataset):\\n loop_over_dataset(dataset, self.process_event,\\n branch_selection=hax.config['basic_branches'] + list(self.extra_branches))\\n self.check_cache(force_empty=True)\\n if not hasattr(self, 'data'):\\n raise RuntimeError(\\\"Not a single event was extracted from dataset %s!\\\" % dataset)\\n else:\\n return self.data\",\n \"def extract_data():\\n logging.info(f'Reading data from {impftermine.agg_export_file_name()}...')\\n df_wl = pd.read_csv(impftermine.agg_export_file_name())\\n vacc_report_file = os.path.join(credentials.vmdl_path, 'vaccination_report_bs_age_group_long.csv')\\n logging.info(f'Reading data from {vacc_report_file}...')\\n df_impf = pd.read_csv(vacc_report_file)\\n return df_wl, df_impf\",\n \"def get_ensembles_summary():\\n\\tregions = request.args.get('region', '').split()\\n\\tregions = [ region.lower() for region in regions ]\\n\\t# Remove suffix after \\\"-\\\" -- for compatibility with Dong lab iConnectome\\n\\tregions = [ re.sub(r'-.*','',region) for region in regions ]\\n\\tregions_tgt = request.args.get('region_tgt', '').split()\\n\\tregions_tgt = [ region_tgt.lower() for region_tgt in regions_tgt ]\\n\\t\\n\\tensemble_list=[]\\n\\tensemble_list = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT * FROM ensembles\\\").fetchall()\\n\\n\\ttotal_methylation_cell_each_dataset = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT dataset, COUNT(*) as `num` FROM cells GROUP BY dataset\\\").fetchall()\\n\\ttotal_snATAC_cell_each_dataset = db.get_engine(current_app, 'snATAC_data').execute(\\\"SELECT dataset, COUNT(*) as `num` FROM cells GROUP BY dataset\\\").fetchall()\\n\\ttotal_methylation_cell_each_dataset = pd.DataFrame(total_methylation_cell_each_dataset, columns=['dataset','num']).set_index('dataset')\\n\\ttotal_snATAC_cell_each_dataset = pd.DataFrame(total_snATAC_cell_each_dataset, columns=['dataset','num']).set_index('dataset')\\n\\n\\tensembles_cell_counts = []\\n\\tfor ensemble in ensemble_list:\\n\\t\\tdatasets = ensemble['datasets'].split(',')\\n\\t\\tmethylation_cell_counts=total_methylation_cell_each_dataset.filter(datasets,axis=0)['num'].to_dict()\\n\\t\\tsnATAC_cell_counts=total_snATAC_cell_each_dataset.filter(datasets,axis=0)['num'].to_dict()\\n\\t\\tannoj_exists = ensemble_annoj_exists(ensemble['ensemble_id'])\\n\\t\\tensembles_cell_counts.append( {\\\"id\\\": ensemble['ensemble_id'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ensemble\\\": ensemble['ensemble_name'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ens_methylation_counts\\\": methylation_cell_counts,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ens_snATAC_counts\\\": snATAC_cell_counts,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"public_access\\\": ensemble['public_access'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"description\\\": ensemble['description'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"annoj_exists\\\": annoj_exists,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"datasets\\\": datasets\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t })\\n\\n\\t# aba_regions = db.get_engine(current_app, 'methylation_data').execute('SELECT * FROM ABA_regions').fetchall()\\n\\taba_regions = pd.read_sql('SELECT * FROM ABA_regions', db.get_engine(current_app, 'methylation_data'))\\n\\taba_regions = aba_regions\\n\\t\\n\\tensembles_json_list = []\\n\\tfor ens in ensembles_cell_counts:\\n\\t\\ttotal_methylation_cells = 0\\n\\t\\ttotal_snATAC_cells = 0\\n\\t\\tdatasets_in_ensemble_cell_count = []\\n\\t\\tdatasets_in_ensemble = []\\n\\t\\tsnATAC_datasets_in_ensemble = []\\n\\t\\tens_dict = {}\\n\\t\\tif ens['ens_methylation_counts'] is not None:\\n\\t\\t\\tfor dataset, count in ens['ens_methylation_counts'].items():\\n\\t\\t\\t\\tens_dict[dataset] = str(count)\\n\\t\\t\\t\\ttotal_methylation_cells += count\\n\\t\\t\\t\\tdatasets_in_ensemble.append(dataset)\\n\\t\\t\\t\\tdatasets_in_ensemble_cell_count.append(dataset+\\\" (\\\"+str(count)+\\\" cells)\\\")\\n\\t\\t\\t\\t# ens_dict[dataset] = str(count) + '/' + str(total_methylation_cell_each_dataset[dataset])\\n\\t\\tif ens['ens_snATAC_counts'] is not None:\\n\\t\\t\\tfor dataset, count in ens['ens_snATAC_counts'].items():\\n\\t\\t\\t\\ttotal_snATAC_cells += count\\n\\t\\t\\t\\tdatasets_in_ensemble.append('CEMBA_'+dataset)\\n\\t\\t\\t\\tsnATAC_datasets_in_ensemble.append(dataset+\\\" (\\\"+str(count)+\\\" cells)\\\")\\n\\n\\n\\t\\t# Do not display ensembles that contain less than 200 total cells. (mainly RS2 data)\\n\\t\\tif total_methylation_cells>0 or total_snATAC_cells>0:\\n\\n\\t\\t\\tens_dict[\\\"ensemble_id\\\"] = ens['id']\\n\\t\\t\\tens_dict[\\\"ensemble_name\\\"] = ens['ensemble']\\n\\t\\t\\tens_dict[\\\"description\\\"] = ens['description']\\n\\t\\t\\tens_dict[\\\"datasets_rs1\\\"] = \\\", \\\".join(sorted([x for x in datasets_in_ensemble_cell_count if 'RS2' not in x]))\\n\\t\\t\\tens_dict[\\\"datasets_rs2\\\"] = \\\", \\\".join(sorted([x for x in datasets_in_ensemble_cell_count if 'RS2' in x]))\\n\\t\\t\\trs2_datasets_in_ensemble = sorted([x for x in datasets_in_ensemble if 'RS2' in x])\\n\\t\\t\\tens_dict[\\\"target_regions_rs2_acronym\\\"] = \\\"\\\"\\n\\t\\t\\tens_dict[\\\"target_regions_rs2_descriptive\\\"] = \\\"\\\"\\n\\t\\t\\tens_dict[\\\"ABA_regions_acronym\\\"] = ''\\n\\t\\t\\tens_dict[\\\"ABA_regions_description\\\"] = ''\\n\\n\\t\\t\\t# TODO: \\n\\t\\t\\tif len(rs2_datasets_in_ensemble) != 0:\\n\\t\\t\\t\\ttarget_regions_query = \\\"SELECT DISTINCT datasets.target_region, ABA_regions.ABA_description \\\\\\n\\t\\t\\t\\t\\tFROM datasets \\\\\\n\\t\\t\\t\\t\\tINNER JOIN ABA_regions ON ABA_regions.ABA_acronym=datasets.target_region \\\\\\n\\t\\t\\t\\t\\tAND datasets.dataset in (\\\" + \\\",\\\".join((\\\"%s\\\",) * len(rs2_datasets_in_ensemble)) + \\\")\\\"\\n\\t\\t\\t\\ttarget_regions_result = db.get_engine(current_app, 'methylation_data').execute(target_regions_query, tuple(rs2_datasets_in_ensemble,)).fetchall()\\n\\t\\t\\t\\tens_dict[\\\"target_regions_rs2_acronym\\\"] = \\\", \\\".join([ x.target_region for x in target_regions_result ])\\n\\t\\t\\t\\tens_dict[\\\"target_regions_rs2_descriptive\\\"] = \\\", \\\".join([ x.ABA_description for x in target_regions_result ])\\n\\n\\t\\t\\t\\t# target_regions_result = aba_regions.loc[rs2_datasets_in_ensemble,'ABA_description']\\n\\n\\t\\t\\tens_dict[\\\"snATAC_datasets_rs1\\\"] = \\\", \\\".join(sorted([x for x in snATAC_datasets_in_ensemble if 'RS2' not in x]))\\n\\t\\t\\tens_dict[\\\"snATAC_datasets_rs2\\\"] = \\\", \\\".join(sorted([x for x in snATAC_datasets_in_ensemble if 'RS2' in x]))\\n\\t\\t\\tens_dict[\\\"num_datasets\\\"] = len(datasets_in_ensemble_cell_count)+len(snATAC_datasets_in_ensemble)\\n\\n\\t\\t\\tslices_list_rs1 = re.findall('CEMBA_([0-9]+[A-Z])',','.join(ens['datasets']))\\n\\t\\t\\tslices_list_rs2 = re.findall('CEMBA_RS2_[A-Z][mf]([0-9]+[A-Z])',','.join(ens['datasets']))\\n\\t\\t\\tslices_set = set(slices_list_rs1)\\n\\t\\t\\tslices_set.update(slices_list_rs2)\\n\\t\\t\\tens_dict[\\\"slices\\\"] = \\\", \\\".join(sorted(list(slices_set)))\\n\\t\\t\\tens_dict[\\\"total_methylation_cells\\\"] = total_methylation_cells\\n\\t\\t\\tens_dict[\\\"total_snATAC_cells\\\"] = total_snATAC_cells\\n\\n\\t\\t\\tif slices_set:\\n\\t\\t\\t\\tens_regions_acronyms = aba_regions.set_index('code').loc[list(slices_set),'ABA_acronym'].values\\n\\t\\t\\t\\tens_regions_descriptions = aba_regions.set_index('code').loc[list(slices_set),'ABA_description'].values\\n\\t\\t\\t\\tens_dict[\\\"ABA_regions_acronym\\\"] = \\\", \\\".join(ens_regions_acronyms).replace('+',', ')\\n\\t\\t\\t\\tens_dict[\\\"ABA_regions_description\\\"] = \\\", \\\".join(ens_regions_descriptions).replace('+',', ')\\n\\n\\t\\t\\tif ens['public_access'] == 0:\\n\\t\\t\\t\\tens_dict[\\\"public_access_icon\\\"] = \\\"fas fa-lock\\\"\\n\\t\\t\\t\\tens_dict[\\\"public_access_color\\\"] = \\\"black\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\tens_dict[\\\"public_access_icon\\\"] = \\\"fas fa-lock-open\\\"\\n\\t\\t\\t\\tens_dict[\\\"public_access_color\\\"] = \\\"green\\\"\\n\\n\\t\\t\\tens_dict[\\\"annoj_exists\\\"] = ens['annoj_exists']\\n\\n\\n\\t\\t\\tuse_region=True\\n\\t\\t\\tif regions!=['none']:\\n\\t\\t\\t\\tuse_region = use_region and (len([region for region in regions if region in ens_dict[\\\"ABA_regions_acronym\\\"].lower()])>0)\\n\\t\\t\\tif regions_tgt!=['none']:\\n\\t\\t\\t\\tuse_region = use_region and (len([region_tgt for region_tgt in regions_tgt if region_tgt in ens_dict[\\\"target_regions_rs2_acronym\\\"].lower()])>0)\\n\\t\\t\\tif use_region:\\n\\t\\t\\t\\tensembles_json_list.append(ens_dict)\\n\\n\\tens_json = json.dumps(ensembles_json_list)\\n\\n\\treturn ens_json\",\n \"def get_gene_by_name(gene_query):\\n\\n\\tgene_query = [ gene.lower()+\\\"%\\\" for gene in gene_query ]\\n\\n\\tsql_query = \\\"SELECT * FROM genes WHERE \\\" + \\\"lower(gene_name) LIKE %s OR \\\" * len(gene_query)\\n\\tsql_query = sql_query[:-3]\\n\\n\\tdf = pd.read_sql(sql_query, params=(gene_query,), con=db.get_engine(current_app, 'methylation_data'))\\n\\n\\treturn df.to_dict('records')\",\n \"async def test_get_transcripts_from_gene(test_db):\\n resp = await test_db.get_transcripts_from_gene(\\\"BRAF\\\", 2145, 2145)\\n assert len(resp) == 32\\n\\n resp = await test_db.get_transcripts_from_gene(\\\"BRAF\\\", 140453136,\\n 140453136)\\n assert len(resp) == 0\",\n \"def getFasta(fileGI,fileout = \\\"gis.fasta\\\", outfmt = \\\"fasta\\\"):\\n myGIs = open(fileGI).read().split()\\n gilist = [\\\",\\\".join(myGIs[i:i+500]) for i in range(0,len(myGIs),500)]\\n from Bio import Entrez\\n import time\\n fout = open(fileout,\\\"w\\\")\\n Entrez.email = \\\"ks2074@gmail.com\\\"\\n for ele in gilist:\\n handle = Entrez.efetch(db = \\\"protein\\\", id = ele, rettype = outfmt, retmode = \\\"text\\\")\\n fout.write(handle.read())\\n time.sleep(3)\\n fout.close()\",\n \"def data(dataset=\\\"bio_eventrelated_100hz\\\"):\\n # TODO: one could further improve this function with like\\n # selectors 'ecg=True, eda=True, restingstate=True' that would\\n # find the most appropriate dataset\\n\\n dataset = dataset.lower()\\n\\n # TODO: change this path back to \\\"master\\\"\\n path = \\\"https://raw.githubusercontent.com/neuropsychology/NeuroKit/dev/data/\\\"\\n\\n # Signals as vectors =======================\\n if dataset in [\\\"eeg\\\", \\\"eeg_150hz\\\", \\\"eeg.txt\\\"]:\\n return pd.read_csv(path + \\\"eeg.txt\\\").values[:, 0]\\n\\n if dataset in [\\\"rsp\\\", \\\"rsp_1000hz\\\", \\\"rsp_1000hz.txt\\\"]:\\n return pd.read_csv(path + \\\"rsp_1000hz.txt\\\", header=None).values[:, 0]\\n\\n if dataset in [\\\"ecg\\\", \\\"ecg_1000hz\\\", \\\"ecg_1000hz.csv\\\"]:\\n return pd.read_csv(path + \\\"ecg_1000hz.csv\\\")[\\\"ECG\\\"].values\\n\\n if dataset in [\\\"ecg_3000hz\\\", \\\"ecg_3000hz.csv\\\"]:\\n return pd.read_csv(path + \\\"ecg_1000hz.csv\\\")[\\\"ECG\\\"].values\\n\\n if dataset in [\\\"eog\\\", \\\"veog\\\", \\\"eog_100hz\\\", \\\"eog_100hz.csv\\\"]:\\n return pd.read_csv(path + \\\"eog_100hz.csv\\\")[\\\"vEOG\\\"].values\\n\\n # Dataframes ===============================\\n if dataset == \\\"iris\\\":\\n info = sklearn_datasets.load_iris()\\n data = pd.DataFrame(\\n info.data, columns=[\\\"Sepal.Length\\\", \\\"Sepal.Width\\\", \\\"Petal.Length\\\", \\\"Petal.Width\\\"]\\n )\\n data[\\\"Species\\\"] = info.target_names[info.target]\\n return data\\n\\n if dataset in [\\\"eogs\\\", \\\"eogs_200hz\\\", \\\"eog_200hz\\\", \\\"eog_200hz.csv\\\"]:\\n return pd.read_csv(path + \\\"eog_200hz.csv\\\")\\n\\n # Add extension\\n if dataset in [\\\"bio_resting_8min_200hz\\\"]:\\n dataset += \\\".json\\\"\\n\\n # Specific case for json file\\n if dataset.endswith(\\\".json\\\"):\\n if \\\"https\\\" not in dataset:\\n data = pd.read_json(path + dataset, orient=\\\"index\\\")\\n else:\\n data = pd.read_json(dataset, orient=\\\"index\\\")\\n df = {}\\n for participant, row in data.iterrows():\\n for _, data_string in row.items():\\n data_list = json.loads(data_string)\\n data_pd = pd.DataFrame(data_list)\\n df[participant] = data_pd\\n\\n return df\\n\\n # TODO: Add more EEG (fif and edf datasets)\\n if dataset in [\\\"eeg_1min_200hz\\\"]:\\n\\n return pickle.load(\\n urllib.request.urlopen(\\n \\\"https://github.com/neuropsychology/NeuroKit/blob/dev/data/eeg_1min_200hz.pickle?raw=true\\\"\\n )\\n )\\n\\n # General case\\n file, ext = os.path.splitext(dataset) # pylint: disable=unused-variable\\n if ext == \\\"\\\":\\n df = pd.read_csv(path + dataset + \\\".csv\\\")\\n else:\\n if \\\"https\\\" not in dataset:\\n df = pd.read_csv(path + dataset)\\n else:\\n df = pd.read_csv(dataset)\\n return df\",\n \"def get_gloffis_data():\\n data_params = DATASETS_VIS['gloffis']\\n\\n r = request.get_json()\\n\\n dataset = r['dataset']\\n assert (dataset in data_params), '{} not in assets. '.format(dataset)\\n data_params = data_params[dataset]\\n\\n band = r['band']\\n assert band in data_params['bandNames'].keys(), '{} not in bands. '.format(band)\\n\\n # Get collection based on dataset requested\\n collection = ee.ImageCollection(data_params['source'])\\n\\n if 'date' in r:\\n start = ee.Date(r['date'])\\n collection = collection.filterDate(start)\\n # check that at least one image returned. If not, return error\\n n_images = collection.size().getInfo()\\n if not n_images:\\n msg = 'No images available for time: %s' % (r['date'])\\n logger.debug(msg)\\n raise error_handler.InvalidUsage(msg)\\n\\n image = ee.Image(collection.sort('system:time_start', False).first())\\n image_date = collection.sort('system:time_start', False).first().date().format().getInfo()\\n\\n image = image.select(band)\\n\\n vis_params = {\\n 'min': data_params['min'][band],\\n 'max': data_params['max'][band],\\n 'palette': data_params['palette'][band]\\n }\\n\\n if dataset == 'hydro':\\n image = image.mask(image.gte(0))\\n\\n if band == 'discharge_routed_simulated':\\n image = image.log()\\n\\n if 'min' in r:\\n vis_params['min'] = r['min']\\n\\n if 'max' in r:\\n vis_params['max'] = r['max']\\n\\n if 'palette' in r:\\n vis_params['palette'] = r['palette']\\n\\n info = generate_image_info(image, vis_params)\\n info['dataset'] = dataset\\n info['band'] = band\\n info['date'] = image_date\\n\\n if band == 'discharge_routed_simulated':\\n info['min'] = 10**vis_params['min']\\n info['max'] = 10**vis_params['max']\\n\\n return Response(\\n json.dumps(info),\\n status=200,\\n mimetype='application/json'\\n )\",\n \"def getDataAt(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\\n ...\",\n \"def get_glossis_data():\\n data_params = DATASETS_VIS['glossis']\\n\\n r = request.get_json()\\n dataset = r['dataset']\\n\\n assert (dataset in data_params), '{} not in assets. '.format(dataset)\\n data_params = data_params[dataset]\\n # Get collection based on dataset requested\\n collection = ee.ImageCollection(data_params['source'])\\n\\n if 'date' in r:\\n start = ee.Date(r['date'])\\n collection = collection.filterDate(start)\\n # check that at least one image returned. If not, return error\\n n_images = collection.size().getInfo()\\n if not n_images:\\n msg = 'No images available for time: %s' % (r['date'])\\n logger.debug(msg)\\n raise error_handler.InvalidUsage(msg)\\n\\n image = ee.Image(collection.sort('system:time_start', False).first())\\n image_date = image.date().format().getInfo()\\n # image_id = image.id().getInfo()\\n\\n # Generate image on dataset requested (characteristic to display)\\n band = r.get('band', list(data_params['bandNames'].keys())[0])\\n assert band in data_params['bandNames']\\n\\n\\n if dataset in ['wind', 'currents']:\\n function = r.get('function', 'magnitude')\\n assert function in data_params['function']\\n if function == 'magnitude':\\n image = image.pow(2).reduce(ee.Reducer.sum()).sqrt()\\n vis_params = {\\n 'min': data_params['min'][function],\\n 'max': data_params['max'][function],\\n 'palette': data_params['palette'][function]\\n }\\n else:\\n image = image.unitScale(data_params['min'][function], data_params['max'][function]).unmask(-9999)\\n data_mask = image.eq(-9999).select(data_params['bandNames'][band])\\n image = image.clamp(0, 1).addBands(data_mask)\\n vis_params = {\\n 'min': data_params['min'][function],\\n 'max': data_params['max'][function]\\n }\\n else:\\n image = image.select(data_params['bandNames'][band])\\n vis_params = {\\n 'min': data_params['min'][band],\\n 'max': data_params['max'][band],\\n 'palette': data_params['palette'][band]\\n }\\n\\n if 'min' in r:\\n vis_params['min'] = r['min']\\n\\n if 'max' in r:\\n vis_params['max'] = r['max']\\n\\n if 'palette' in r:\\n vis_params['palette'] = r['palette']\\n\\n info = generate_image_info(image, vis_params)\\n info['dataset'] = dataset\\n info['date'] = image_date\\n # info['imageId'] = image_id\\n # info['imageSource'] = data_params['source']\\n\\n return Response(\\n json.dumps(info),\\n status=200,\\n mimetype='application/json'\\n )\",\n \"def data(self):\",\n \"def index_gff(gff, logger):\\n f_in = open(gff, \\\"r\\\")\\n gene_start_stop_dict = dict()\\n gene_scaff_dict = dict()\\n gene_first_exon_dict = dict()\\n gene_direction = dict()\\n gene_gff_line = dict()\\n gene_set = set([])\\n for line in f_in:\\n if line.startswith(\\\"#\\\"):\\n continue\\n if not line.strip():\\n continue\\n assert len(line.split(\\\"\\\\t\\\")) == 9 , \\\"GFF fields wrong length should be 9\\\"\\n scaff, source, feature, start, stop, score, \\\\\\n direction, frame, gene_info = line.split(\\\"\\\\t\\\")\\n gene = split_gene_name(gene_info)\\n scaff = scaff.rstrip()\\n if feature == \\\"gene\\\":\\n gene_gff_line[gene] = line\\n gene_set.add(gene)\\n start_stop = \\\"%s\\\\t%s\\\" % (start, stop)\\n gene_start_stop_dict[gene] = start_stop\\n gene_scaff_dict[gene] = scaff\\n gene_direction[gene] = direction\\n if not gene in gene_first_exon_dict.keys():\\n if feature == \\\"exon\\\" or feature == \\\"CDS\\\":\\n start_stop = \\\"%s\\\\t%s\\\" % (start, stop)\\n gene_first_exon_dict[gene] = start_stop\\n f_in.close()\\n logger.info(\\\"Number of genes = %d\\\", len(gene_set))\\n return gene_start_stop_dict, gene_first_exon_dict, \\\\\\n gene_scaff_dict, gene_direction, gene_set, gene_gff_line\",\n \"def _get_datas(self):\\n print(f'base name {self.base_name}')\\n data_file_name = glob(osp.join(self.root_dir, MERGED_PATTERN))[0]\\n data_df = pd.read_csv(data_file_name)\\n\\n ppg_d = data_df[['CurrentTimeMillis', 'ch1']].values\\n acc_d = data_df[[\\n 'EventTimestamp(ns)', 'accel_x', 'accel_y', 'accel_z'\\n ]].values\\n ppg_d = ppg_d[::2]\\n acc_d = acc_d[::2]\\n\\n return acc_d, ppg_d\",\n \"def get_sequences(data_path, gene):\\n \\n sequence_file = os.path.join(data_path, gene + \\\".fasta\\\")\\n try:\\n sequences_gene = sequence.Sequence.create(file = sequence_file, input_format = 'fasta')\\n except FileNotFoundError:\\n print(\\\"Did not found {} in {}.\\\".format(gene,data_path))\\n sequences_gene = \\\"Did not found {} in {}.\\\".format(gene,data_path)\\n except:\\n print(\\\"Unexpected Error while trying to get the sequence from {}.\\\".format(sequence_file))\\n sequences_gene = \\\"Unexpected Error while trying to get the sequence from {}.\\\".format(sequence_file)\\n # print(\\\"sequences_gene\\\", sequences_gene)\\n return sequences_gene\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6190661","0.60675555","0.60619366","0.58405983","0.5830618","0.5788245","0.5680454","0.568016","0.56783557","0.56729907","0.56712174","0.5638997","0.56313276","0.5628834","0.5569161","0.5562359","0.5537546","0.55343705","0.55274814","0.55243385","0.5518902","0.5510672","0.55099183","0.5509502","0.54665047","0.5421924","0.5399531","0.5389986","0.53784114","0.53752816","0.5374821","0.53699046","0.53640133","0.5360581","0.5357446","0.53559595","0.53559595","0.53559595","0.53421843","0.5339111","0.533111","0.53249496","0.53237474","0.5315247","0.5312059","0.5306798","0.5306024","0.5303549","0.5299768","0.52986723","0.5291518","0.5269461","0.52668136","0.5263625","0.5263625","0.52602047","0.5253555","0.5251335","0.5247488","0.52446365","0.5240133","0.5225892","0.5217919","0.5214319","0.52066374","0.5205912","0.52007663","0.5195485","0.5188671","0.51783806","0.5177885","0.5169661","0.51663375","0.5165472","0.5165295","0.51634634","0.51618767","0.5159902","0.5159301","0.51531607","0.5147133","0.51396215","0.5133821","0.5117697","0.51164806","0.51118183","0.5109867","0.5108418","0.5107479","0.5103756","0.51035446","0.50941896","0.5086063","0.50808257","0.50785804","0.5073836","0.5073016","0.5070457","0.50691205","0.5058394","0.5055722"],"string":"[\n \"0.6190661\",\n \"0.60675555\",\n \"0.60619366\",\n \"0.58405983\",\n \"0.5830618\",\n \"0.5788245\",\n \"0.5680454\",\n \"0.568016\",\n \"0.56783557\",\n \"0.56729907\",\n \"0.56712174\",\n \"0.5638997\",\n \"0.56313276\",\n \"0.5628834\",\n \"0.5569161\",\n \"0.5562359\",\n \"0.5537546\",\n \"0.55343705\",\n \"0.55274814\",\n \"0.55243385\",\n \"0.5518902\",\n \"0.5510672\",\n \"0.55099183\",\n \"0.5509502\",\n \"0.54665047\",\n \"0.5421924\",\n \"0.5399531\",\n \"0.5389986\",\n \"0.53784114\",\n \"0.53752816\",\n \"0.5374821\",\n \"0.53699046\",\n \"0.53640133\",\n \"0.5360581\",\n \"0.5357446\",\n \"0.53559595\",\n \"0.53559595\",\n \"0.53559595\",\n \"0.53421843\",\n \"0.5339111\",\n \"0.533111\",\n \"0.53249496\",\n \"0.53237474\",\n \"0.5315247\",\n \"0.5312059\",\n \"0.5306798\",\n \"0.5306024\",\n \"0.5303549\",\n \"0.5299768\",\n \"0.52986723\",\n \"0.5291518\",\n \"0.5269461\",\n \"0.52668136\",\n \"0.5263625\",\n \"0.5263625\",\n \"0.52602047\",\n \"0.5253555\",\n \"0.5251335\",\n \"0.5247488\",\n \"0.52446365\",\n \"0.5240133\",\n \"0.5225892\",\n \"0.5217919\",\n \"0.5214319\",\n \"0.52066374\",\n \"0.5205912\",\n \"0.52007663\",\n \"0.5195485\",\n \"0.5188671\",\n \"0.51783806\",\n \"0.5177885\",\n \"0.5169661\",\n \"0.51663375\",\n \"0.5165472\",\n \"0.5165295\",\n \"0.51634634\",\n \"0.51618767\",\n \"0.5159902\",\n \"0.5159301\",\n \"0.51531607\",\n \"0.5147133\",\n \"0.51396215\",\n \"0.5133821\",\n \"0.5117697\",\n \"0.51164806\",\n \"0.51118183\",\n \"0.5109867\",\n \"0.5108418\",\n \"0.5107479\",\n \"0.5103756\",\n \"0.51035446\",\n \"0.50941896\",\n \"0.5086063\",\n \"0.50808257\",\n \"0.50785804\",\n \"0.5073836\",\n \"0.5073016\",\n \"0.5070457\",\n \"0.50691205\",\n \"0.5058394\",\n \"0.5055722\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12880,"cells":{"query":{"kind":"string","value":"Get fold change averaged data for gene. This is useful as it formats data for input into copasi"},"document":{"kind":"string","value":"def get_data_copasi_style_d3ct(self, gene, cell_line='A', plot=False, new_name=None,\n filename=None, indep_dct=None):\n if gene not in self.genes:\n raise ValueError('{} is not in list of genes \"{}\"'.format(gene, self.genes))\n df = self.d3ct.query('cell_line == \"{}\" and Assay == \"{}\"'.format(cell_line, gene))\n df = pandas.pivot_table(df, values=0, index=['cell_line', 'replicate'], columns='time')\n mean = df.mean(axis=0)\n if new_name is not None:\n mean = pandas.DataFrame(mean, columns=[new_name])\n else:\n mean = pandas.DataFrame(mean, columns=[gene])\n\n mean = mean.reset_index()\n mean['time'] = mean['time']*60\n mean.loc[0] = [0, 0]\n\n if indep_dct is not None:\n for i in indep_dct:\n if i[-5:] != '_indep':\n raise ValueError('Keys in indep_dct shuold have _indep as suffix')\n\n mean[i] = indep_dct[i]\n\n if filename is not None:\n mean.to_csv(filename, sep='\\t', index=False)\n\n if plot:\n mean.plot(x='time')\n plt.show()\n\n return mean"},"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 load_average(self):\n return _favg(self.load_samples)","def get_mean(self):\n mean = np.array(np.zeros((4,8)))\n for i,c in enumerate(self.cellLines):\n for j,l in enumerate(self.ligands):\n mean[i][j] = self.aucs[c][l]['mean']\n return mean","def mean_ensembler(self):\n models_name = self._get_models_name(self.data_dir)\n if type(models_name) != list:\n models_name = [models_name]\n\n get_test_y = self._get_model_val(models_name, self.data_dir, 'test')\n # Calculate the average\n average = pd.DataFrame()\n for add in list(get_test_y.keys()):\n if average.empty:\n average[self.TAGS] = get_test_y[add][self.TAGS]\n else:\n average[self.TAGS] += get_test_y[add][self.TAGS]\n\n average = average/len(list(get_test_y.keys()))\n average.insert(loc=0, column='id', value=self.test_id.values)\n doc_name = self.data_dir + '/' + 'submission_average_ensembler.csv'\n average.to_csv(doc_name, index=False)\n print('submission file saved at {}'.format(doc_name))\n return average","def _ave(self):\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def get_average(self):\n self.avg = math.floor((self.maths + self.phy + self.che) / 3, )\n self.assign_grade()\n return self.avg\n # End of method get_average","def _ave(self):\n\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def get_mean(self):\r\n for i in range(1,len(self.data[0])):\r\n self.prom.append(np.mean(self.data[:,i]))","def ensemble_mean(self):\n new_cubelist = []\n for cube in self.cubelist:\n new_cubelist.append(self.cube_ensemble_mean(cube))\n self.cubelist = iris.cube.CubeList(new_cubelist)\n self.processes.append('ensemble_mean')\n return self.cubelist","def getAvg(self):\r\n\t\treturn self.data['avg']","def average(data):\n return np.average(data)","def get_ave(self, recalc=False):\n if self.ave is not None and not recalc:\n return self.ave\n\n self.ave = np.mean(self.img.ravel())\n return self.ave","def get_original_means(self):\n return self.meanDataValues","def avg_e_score(self, entity):\n return float(entity['es']) / float(entity['count'])","def ensemble_mean(self):\n return self.mean(dim='mem')","def get_average_repro(self):\n return np.mean([agent.get_fledge_probability() for agent in self.agents])","def ensemble_mean(self):\n self.cube = self.cube_ensemble_mean(self.cube)\n self.processes.append('ensemble_mean')\n return self.cube","def get_average(data):\n average = sum(data) / len(data)\n\n return average","def readAvg(self):\n self.flushInput()\n\n if (self.model == 'TDS'):\n self.write('ACQuire:NUMAVg?\\n')\n return int(self.readline())\n #elif (self.model == 'GDS'):\n # FIXME: I'll implement this later. I need to do some\n # testing, re: whether GDS returns the actual average\n # number, or log-base-2 of the average number.","def get_mean_dict(self):\n mean = {}\n for c in self.cellLines:\n mean[c] = {}\n for l in self.ligands:\n mean[c][l] = self.aucs[c][l]['mean']\n return mean","def average(self):\n return self.summation() / self.count()","def annual_average(new_cube):\n\n annual_average_cube = new_cube.aggregated_by('year', iris.analysis.MEAN)\n\n return annual_average_cube","def get_average(self, s_freq, e_freq):\n s_ind = self.get_bin(s_freq)\n e_ind = self.get_bin(e_freq)\n lst = self.mags[s_ind:e_ind+1]\n try:\n avg = sum(lst)/len(lst)\n except:\n print(s_ind, e_ind)\n print('werid stuff')\n avg = 0\n return avg","def get_average_age(self):\n return np.mean([agent.age for agent in self.agents])","def get_mean(self):\n return self.serie.mean()","def gavg(idata):\n\t\n\twgt1=np.cos(np.deg2rad(idata.lat))*(idata*0+1)\n\tga=(wgt1*idata).sum(dim=['lat','lon'])/wgt1.sum(dim=['lat','lon'])\n\n\treturn ga","def Mean(data):\n return data.mean()","def _get_mean(self):\n return [layer._get_mean() for layer in self.layers]","def calcAverage(dat):\n return sum(dat)/len(dat)","def slice_avg(self, file_data, slice_range):\n row_num = 0\n feature_data = [0] * 7\n for row in file_data:\n feature_data[row_num] = sum(row[slice_range[0]:slice_range[1]]) / (slice_range[1] - slice_range[0])\n row_num += 1\n self.feature.append(feature_data)","def avg(year):\r\n df = ouvrir_fichier()\r\n df = df.loc[df[\"year\"].isin([year])]\r\n df = df[(\r\n df[\r\n \"emissions\"\r\n ] == 'Emissions (thousand metric tons of carbon dioxide)'\r\n )]\r\n print(df)\r\n mean_value = df.mean()['value']\r\n resultat = {}\r\n resultat[\"year\"] = year\r\n resultat['total'] = float(mean_value)\r\n print(mean_value)\r\n return resultat","def average_grade(self):\n grade_sum = 0\n grades_length = 0\n for c in self.courses_grades:\n if c[1] != \"-\":\n grade_sum += int(c[1])\n grades_length += 1\n average = grade_sum / grades_length\n return average","def compute_fold_regulation(fc_data_list):\n # if isinstance(fc_data_list, list):\n return [{TEST_SAMPLE: fc_elem[TEST_SAMPLE], CONTROL_SAMPLE: fc_elem[CONTROL_SAMPLE],\n FOLD_REGULATION: fc_elem[FOLD_CHANGE].applymap(lambda x: -1.0/x if x < 1.0 else x)}\n for fc_elem in fc_data_list]\n # return fc_data_list.applymap(lambda x: -1.0/x if x < 1.0 else x)","def time_average(new_cube):\n\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\n\n return time_average_cube","def _get_average(self):\n norm = 1.0\n for pos, idx in enumerate(self.idx):\n norm *= (self.high[pos] - self.low[pos])\n return 1.0/norm","def average(self):\n return self.properties.get('average')","def get_mean(self):\n average = self.df[self.col_name].mean()\n return average","def _agg_by_mean(self):\n return self._data_grouped_by_manufacturer.agg('mean')[['car_value']]","def average_length_of_gene(self):\n return sum([len(e) for e in self.population]) / len(self.population)","def get_foldchange(self, exps_for_fc):\n exp_id_str = get_id_str(self.req_exps)\n table_name = '%s_datatable_%s' % (self.app_label, exp_id_str)\n # Make experiment for fold change unique.\n exps_for_fc = get_unique(exps_for_fc)\n if not db_table_exists(table_name):\n self.create_base_table(table_name)\n column_names = list(get_columnnames(table_name))\n # Inititialize lists.\n dividend = [None] * len(exps_for_fc)\n divisor = [None] * len(exps_for_fc)\n fc_col_position = [None] * len(exps_for_fc)\n # Format all columns with scientific notation that end with underscore and a number.\n datacol_pattern = re.compile(r'_\\d+$')\n for i, column_name in enumerate(column_names):\n if datacol_pattern.search(column_name) is not None:\n for j, pair in enumerate(exps_for_fc):\n pattern = r'_{}$'.format(str(pair['dividend'].id))\n if re.search(pattern, column_name):\n if not dividend[j]: \n dividend[j] = (column_name, pair['dividend'].id,)\n # For the jth column there will be j columns inserted before that.\n fc_col_position[j] = i + j\n elif (str(pair['divisor'].id) in column_name and \n not divisor[j]):\n divisor[j] = (column_name, pair['divisor'].id)\n \n # Insert the columns for calculating the fold change.\n for i in range(len(dividend)): \n fc_col = '{quotient} AS {quotient_name}'.format(\n quotient=self.wrap_in_func(self.DB_FUNCTION_ZERO, dividend[i][0], divisor[i][0]),\n quotient_name='\"fc_%s/%s\"' % (dividend[i][1], divisor[i][1]),\n )\n column_names.insert(fc_col_position[i], fc_col)\n \n sql = \"SELECT %s FROM %s\" % (fc_col, table_name)\n return from_db(sql, fetch_as='tuple')","def _compute_cluster_averages(self, key=\"_scvi_labels\"):\n # find cell label column\n label_col = self.adata.uns[\"_scvi\"][\"categorical_mappings\"][key][\"original_key\"]\n\n # find data slot\n x_dict = self.adata.uns[\"_scvi\"][\"data_registry\"][\"X\"]\n if x_dict[\"attr_name\"] == \"X\":\n use_raw = False\n else:\n use_raw = True\n if x_dict[\"attr_name\"] == \"layers\":\n layer = x_dict[\"attr_key\"]\n else:\n layer = None\n\n # compute mean expression of each gene in each cluster/batch\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\n\n return aver","def getMeanE(self):\n\n\n\t\tEBefore, EAfter = self.getEnergyEvolution()\n\n\t\tmeanBefore = np.mean(EBefore[-self.__Nkicks//5:])\n\t\tmeanAfter = np.mean(EAfter[-self.__Nkicks//5:])\n\t\tmeanTot = (meanBefore+meanAfter)/2\n\n\t\treturn meanBefore, meanAfter, meanTot","def average_level(self):\n spl = [utils.dbspl(x) for x in self.load_files()]\n return np.mean(spl), np.std(spl)","def average_matrix(self, groups=[\"SP\", \"SL06\", \"SL12\", \"SL24\",\"SL48\", \"SL96\",\"FP06\", \"FP12\", \"FP24\",\"FP48\", \"FP96\", \"FL\"]):\n\n # will only work if genes are columns in matrix\n revert = False\n if self._genes_as_rows:\n self.invert_matrix()\n revert = True\n\n limits = self.reorder_matrix(groups=groups)\n\n v = numpy.ones((len(groups),self.genenumber)) # create new array of size (y groups) and (n genes)\n\n for g in range(self.genenumber):\n v[0,g] = numpy.average(self.data_matrix[:limits[0],g])\n for i in range(len(groups)-1):\n v[i + 1,g] = numpy.average(self.data_matrix[limits[i]:limits[i + 1],g])\n\n self.row_header = groups\n self.column_header = self.gene_header\n self.data_matrix = v\n self.refresh_headers()\n\n # if matrix was inverted for gene removal, restore to its previous orientation:\n if revert:\n self.invert_matrix()\n self.averaged = True","def calc_average_load (self):\n #~ self.generation = self.forecast.generation_by_type['generation diesel']\\\n #~ [self.start_year]\n self.average_load = \\\n self.forecast.yearly_average_diesel_load.ix[self.start_year]","def _average_data(self):\n # TODO: This function looks inefficient - can it be improved?\n output = np.zeros([self.nints_file, self.ngroups_file,\n self.rows, self.columns], dtype=self.data.dtype)\n count = np.zeros([self.nints_file, self.ngroups_file, 1, 1],\n dtype=self.data.dtype)\n\n for intg in range(0, self.nints):\n intg_file = intg // self.intavg\n for grp in range(0, self.ngroups):\n grp_file = grp // self.grpavg\n output[intg_file, grp_file, :, :] += self.data[intg, grp, :, :]\n count[intg_file, grp_file, 0, 0] += 1.0\n\n # Avoid divide by zero.\n iszero = np.where(count < 1.0)\n if iszero:\n count[iszero] = 1.0\n output = output / count\n\n del count \n return output","def store_overall_means(src_file: H5File) -> None:\n perp_sum = 0\n par_sum = 0\n ref_sum = 0\n counts = 0\n for path in rawnav.pump_group_paths(src_file):\n perp_path = path + '/perp'\n par_path = path + '/par'\n ref_path = path + '/ref'\n perp_sum += src_file[perp_path].attrs['mean']\n par_sum += src_file[par_path].attrs['mean']\n ref_sum += src_file[ref_path].attrs['mean']\n counts += 1\n src_file.attrs['perp_mean'] = perp_sum / counts\n src_file.attrs['par_mean'] = par_sum / counts\n src_file.attrs['ref_mean'] = ref_sum / counts\n return","def avg_added(self):\n avg = {}\n for path, lines in self.lines_added.items():\n avg[path] = round(statistics.mean(lines))\n\n return avg","def calculateAverage(self): \n if not self.lastTransferAverage: \n size=[0,0,0,0]\n for i in range(0,4):\n if self.lastTransferredChannel & (1 << i):\n size[i]=self.lastNbrSamplesPerSeg\n self.lastAverageArray = [zeros(size[0]),zeros(size[1]),zeros(size[2]),zeros(size[3])]\n nbrSamp=self.lastNbrSamplesPerSeg\n for i in range(0,4):\n if self.lastTransferredChannel & (1 << i):\n nbrSeg=self.lastNbrSegmentsArray[i]\n for j in range (0,nbrSamp):\n for k in range(0,nbrSeg): \n self.lastAverageArray[i][j]+=self.lastWaveformArray[i][k*nbrSamp+j]\n self.lastAverageArray[i][j]/=nbrSeg\n self.lastAverageCalculated=True\n else: print \"NOn averaged data are not available\"","def _image_average(self, images):\n image_data = [\n image.normalize().data for image in images\n # Workaround: skip partial volcano images at the edges\n if image.data.shape[0] == image.data.shape[1]\n ]\n return np.rint(\n np.mean(image_data, axis=0)\n ).astype(np.uint8)","def get_mean_accuracy(self):\n return self.df.correct.mean()","def gacha_mean(sourcefile, targetfile):\n sys.stderr.write(err_msg('Calculating Gacha mean, please wait ...\\n'))\n c = num_char(sourcefile) / num_char(targetfile)\n sys.stderr.write(err_msg('Gacha mean = ' + str(c) + '\\n'))\n sys.stderr.write(err_msg('Filtering starts ...\\n'))\n return c","def per_gene_coverage(genes,df):\n\n sub_genes =[]\n\n #For every gene in the list, check the average coverage, if less than 100 add it to the final list.\n for gene in genes:\n coverage = average(df[df['GeneSymbol;Accession'] == gene]['percentage30'])\n\n if coverage < 100:\n sub_genes.append([gene.split(';')[0],round(coverage,2)])\n \n return sub_genes","def calc_average_load (self):\n if self.comp_specs['proposed capacity'] != UNKNOWN:\n self.average_load = None\n self.generation = self.forecast.generation['generation diesel']\\\n [self.start_year]\n self.average_load = \\\n self.forecast.yearly_average_diesel_load.ix[self.start_year]\n #~ print 'self.average_load',self.average_load","def average_strain_data(features, metadata, groups_column='gene_name'):\n\n meta_cols = metadata.columns.to_list() \n data = pd.concat([metadata[groups_column], features], axis=1)\n mean_data = data.groupby(groups_column).mean()\n df = metadata.merge(mean_data, how='right', on=groups_column)\n df = df.groupby(groups_column).first().reset_index()\n \n feat = df[[c for c in df.columns if c not in meta_cols]]\n meta = df[meta_cols]\n \n return feat, meta","def get_average_MAE(true_pred_df): \n age_group = true_pred_df.groupby('y_true')\n \n mae_average = []\n for age, age_data in age_group:\n mae_average.append(np.mean(age_data.mae))\n \n return mae_average","def _get_mean(self):\n return self._get_conditional_negative_energy()","def get_stats(self, gene, groups=[\"SP\", \"SL06\", \"SL12\", \"SL24\",\"SL48\", \"SL96\",\"FP06\", \"FP12\", \"FP24\",\"FP48\", \"FP96\", \"FL\"]):\n\n try:\n pos = self.gene_header.index(gene)\n except:\n return [],[]\n\n limits = [0] + self.reorder_matrix(groups=groups)\n #print limits\n intervals = zip(limits[:-1],limits[1:])\n print \"Debugging: ave and stdev:-\"\n #print intervals\n #print self.data_matrix\n #print self.data_matrix[:,pos]\n #print [ (self.data_matrix[ i:j,pos ]) for i,j in intervals]\n ave = [ numpy.average(self.data_matrix[ i:j,pos ]) for i,j in intervals]\n print ave\n stdev = [ numpy.std(self.data_matrix[ i:j,pos ]) for i,j in intervals]\n print stdev\n return ave, stdev","def average(data):\r\n sum =0\r\n for i in data:\r\n sum+=i\r\n return sum/len(data)","def averaged_risk(self):\n return self._averaged_risk","def averaged_risk(self):\n return self._averaged_risk","def ensemble_perts(self):\n #emean = self.ensemble_mean()\n return self - self.ensemble_mean()\n #return self.state.values","def get_average_mark(self, test):\n return","def run(self, data):\n for idx, block in enumerate(data):\n current = float(np.mean(block['current']['value']))\n print(f'{idx}: {current}')","def mean_calc(data, col):\n\tm = sum([row[col] for row in data]) / len(data)\n\treturn m","def average(self):\n return np.mean(self.buf[:self._size], axis=0)","def average_population_grade(population):\r\n total = 0\r\n for individual in population :\r\n total += get_individual_fitness(individual)\r\n return total/POPULATION_COUNT","def compute_averaged_values(filenames, cols, skip=0, stop=-1, column_major=False, separator='[\\t ]'):\n\n # Read columns\n all_cols = read_file_lines(filenames, cols, skip, stop, column_major, separator)\n\n # Initialise results array\n res = [np.zeros(len(i)) for i in all_cols[0]]\n\n # For each set of columns\n for file_data in all_cols:\n # For each column of the file\n for num, col in enumerate(file_data):\n # Add the value divided by the amount of files considered (to get the average)\n res[num] += col/len(all_cols)\n\n return res","def test_liemdframe_get_average(self):\n\n ave = self.mdframe.get_average()\n\n # Unbound energies should be same value for all poses\n self.assertEqual(len(ave['coul_unbound'].unique()), 1)\n self.assertEqual(len(ave['coul_unbound']), 5)\n self.assertEqual(len(ave['vdw_unbound'].unique()), 1)\n self.assertEqual(len(ave['vdw_unbound']), 5)\n\n # Bound energies mostly unique for all poses\n self.assertEqual(len(ave['coul'].unique()), 5)\n self.assertEqual(len(ave['vdw'].unique()), 5)\n self.assertEqual(len(ave['coul']), 5)\n self.assertEqual(len(ave['vdw']), 5)\n\n # Check values\n self.assertListEqual(list(ave.poses), [1, 2, 3, 4, 5])\n self.assertListEqual(list(ave.cases), [1])\n self.assertAlmostEqual(ave['coul'][0], 60.12452, places=5)\n self.assertAlmostEqual(ave['vdw'][1], -53.78007, places=5)","def calculate_mean(data_dir):\n data = ([each for each in os.listdir(data_dir)\n if each.endswith('.h5')])\n all_data = []\n for num_data in data:\n processed_data = os.path.join(data_dir, num_data)\n file = h5py.File(processed_data, 'r') \n data = file.get('Processed_data') \n all_data.append(data)\n all_data = np.array(all_data)\n all_data = np.mean(all_data, axis=0)\n return all_data","def compute_GS(GMtcs):\n\n GS = np.mean(GMtcs,axis=0) #average over voxels\n\n return GS","def get_rolling_mean_provenance(self, suptitle, ancestor_files):\n suptitle = suptitle.replace('\\n', '')\n caption = (f\"{suptitle}. For CMIP5 (\"\n f\"{self.formatter(f'cmip5-{self.scenarios[0]}')}, \"\n f\"{self.formatter(f'cmip5-{self.scenarios[1]}')} and \"\n f\"{self.formatter(f'cmip5-{self.scenarios[2]}')}) \"\n f\"and CMIP6 \"\n f\"({self.formatter(f'cmip6-{self.scenarios[0]}')}, \"\n f\"{self.formatter(f'cmip6-{self.scenarios[1]}')} and \"\n f\"{self.formatter(f'cmip6-{self.scenarios[2]}')})\")\n\n record = {\n 'caption': caption,\n 'statistics': ['anomaly', \"other\"],\n 'domains': ['reg', 'global'],\n 'plot_types': ['scatter', 'line', 'times'],\n 'authors': [\n 'cos_josep',\n ],\n 'references': [\n 'cos22esd',\n ],\n 'ancestors': ancestor_files,\n }\n return record","def average_emission(data: List[EmissionPerCapita], current_year: int) -> float:\r\n\r\n index = current_year - data[0].start_year # get the index for current year\r\n\r\n # Get all emissions from that year.\r\n current_year_emissions = []\r\n for countries in data:\r\n current_year_emissions.append(countries.epc_year[index])\r\n\r\n average = sum(current_year_emissions) / len(data)\r\n return average","def mean_height(data):","def mean_height(data):","def average_age():\n df = pd.read_csv(config.META_FQN, sep=\"\\t\")\n ages = []\n for _, row in df.iterrows():\n if row[\"asr_test\"]:\n age = row[\"Age_ses1\"]\n if not math.isnan(age):\n ages.append(age)\n\n print(\"------ Age ------\")\n print_stats(ages)","def mean(self):\n return self._summarize(lambda c: c.mean)","def average(self, returns):\r\n return returns.mean() * self.day","def _compute_mean(self, C, mag, rjb, rake):\n mean = (C['a1'] +\n self._compute_linear_magnitude_term(C, mag) +\n self._compute_quadratic_magnitude_term(C, mag) +\n self._compute_logarithmic_distance_term(C, mag, rjb) +\n self._compute_faulting_style_term(C, rake))\n\n return mean","def _get_mean(self):\n return (0.485, 0.456, 0.406)","def print_avg():","def test_mean_div(self):\n gfile = grades.writers.GradesFile(self.fname)\n gfile.table.compute_mean()\n gfile.table_format = 'org'\n self.check_output(self.output_str3, gfile, div_on=('Group', 'Test 1'))","def global_mean(self):\n return self.interaction_data.label.mean()","def get_average(self, samples=50):\n first = self.layers[0].load_image()\n res = np.zeros(first.shape, dtype=float)\n intervals = len(self.layers)/samples\n for l in self.layers[::int(intervals)]:\n img = l.load_image().astype(float)\n res += img\n l.image = None\n return samples**-1*res","def get_avg_f1(ccs):\n scorers = ccs.scorers\n f1_scores = []\n for scorer in scorers:\n f1_scores.append(scorer.get_f1())\n\n avg_f1 = 100 * np.average(f1_scores)\n\n return avg_f1","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def get_average_torsion (phis) :\n shift = phis[0]\n phis_shifted = get_diffvec(phis,shift)\n avg_shifted = phis_shifted.sum()/len(phis)\n average = avg_shifted + shift\n return average","def get_average_torsion (phis) :\n shift = phis[0]\n phis_shifted = get_diffvec(phis,shift)\n avg_shifted = phis_shifted.sum()/len(phis)\n average = avg_shifted + shift\n return average","def mpg_by_make(self):\n ## create reference dict and aggregated dict\n reference_mpgs = defaultdict(list)\n make_avg_mpgs = defaultdict(str)\n ## loop through the data and add to both dicts\n for auto in self.data:\n ## get the year\n the_make = auto.make\n ## maintain a list of mpgs for each key=make\n reference_mpgs[the_make].append(auto.mpg)\n ## update the cumulative mpg as we read auto objects\n make_avg_mpgs[the_make] = sum(reference_mpgs[the_make]) / len(reference_mpgs[the_make])\n return make_avg_mpgs","def calculate_mean_dark(data_dir):\n\n data = ([each for each in os.listdir(data_dir)\n if each.endswith('.h5')])\n \n all_data = []\n for num_data in data:\n #print(num_data)\n processed_data = os.path.join(data_dir, num_data)\n file = h5py.File(processed_data, 'r') \n data = file.get('Processed_data')\n all_data.append(data)\n #print\n\n all_data = np.array(all_data)\n all_data = np.mean(all_data, axis=0)\n return all_data","def cf_mean(self):\n net_power = self['annual_gross_energy'] \\\n - self['annual_thermal_consumption'] # kW-hr\n # q_pb_des is in MW, convert to kW-hr\n name_plate = self['q_pb_design'] * 8760 * 1000\n\n return net_power / name_plate","def get_averages(self):\t\n\t\t\n\t\taverages = {}\n\t\tfor subject in self.grades.iterkeys():\n\t\t\taverages[subject] = float(sum(self.grades[subject])) / len(self.grades[subject])\n\t\treturn averages","def clr_trans(data):\n if isinstance(data, pd.DataFrame):\n data = data.to_numpy()\n data[data == 0] = 1/len(data[0,:])**2 # replace zeros with small constant\n geometric_mean = mstats.gmean(data,axis=1)\n clr_data = np.log(data / geometric_mean[:,None])\n return clr_data","def average(data, event):\n if len(data) == 0:\n return 0\n\n score = 0\n # scores = []\n count = 0\n for i in data:\n count += 1\n if event == 'Swim' or event == 'Run':\n num = time_seconds(i[event])\n #print(\"first if\")\n #Sprint(num)\n else:\n num = int(i[event])\n #print(\"second if\")\n #print(num)\n #scores[count] =\n #print(\"end of loop count\" + str(count))\n score += num\n #print (\"score\" + str(score))\n\n # total = 0\n # for x in range(0,len(scores)):\n # total += scores[x]\n score = float(score)\n\n return score / count","def calccalmean(self,blk):\n calind=self.getcalind(blk)\n x=self.spec[calind,:]\n return np.nanmean(x,axis=0)","def average(X, ebunch):\n edge_embeds = np.zeros((len(ebunch), len(X[list(X.keys())[0]])))\n i = 0\n for edge in ebunch:\n edge_embeds[i] = (X[str(edge[0])] + X[str(edge[1])]) / 2.0\n i += 1\n return edge_embeds","def get_mean(self):\n raise NotImplementedError(\"This is an abstract method and needs to be implemented in derived classes.\")"],"string":"[\n \"def load_average(self):\\n return _favg(self.load_samples)\",\n \"def get_mean(self):\\n mean = np.array(np.zeros((4,8)))\\n for i,c in enumerate(self.cellLines):\\n for j,l in enumerate(self.ligands):\\n mean[i][j] = self.aucs[c][l]['mean']\\n return mean\",\n \"def mean_ensembler(self):\\n models_name = self._get_models_name(self.data_dir)\\n if type(models_name) != list:\\n models_name = [models_name]\\n\\n get_test_y = self._get_model_val(models_name, self.data_dir, 'test')\\n # Calculate the average\\n average = pd.DataFrame()\\n for add in list(get_test_y.keys()):\\n if average.empty:\\n average[self.TAGS] = get_test_y[add][self.TAGS]\\n else:\\n average[self.TAGS] += get_test_y[add][self.TAGS]\\n\\n average = average/len(list(get_test_y.keys()))\\n average.insert(loc=0, column='id', value=self.test_id.values)\\n doc_name = self.data_dir + '/' + 'submission_average_ensembler.csv'\\n average.to_csv(doc_name, index=False)\\n print('submission file saved at {}'.format(doc_name))\\n return average\",\n \"def _ave(self):\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def get_average(self):\\n self.avg = math.floor((self.maths + self.phy + self.che) / 3, )\\n self.assign_grade()\\n return self.avg\\n # End of method get_average\",\n \"def _ave(self):\\n\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def get_mean(self):\\r\\n for i in range(1,len(self.data[0])):\\r\\n self.prom.append(np.mean(self.data[:,i]))\",\n \"def ensemble_mean(self):\\n new_cubelist = []\\n for cube in self.cubelist:\\n new_cubelist.append(self.cube_ensemble_mean(cube))\\n self.cubelist = iris.cube.CubeList(new_cubelist)\\n self.processes.append('ensemble_mean')\\n return self.cubelist\",\n \"def getAvg(self):\\r\\n\\t\\treturn self.data['avg']\",\n \"def average(data):\\n return np.average(data)\",\n \"def get_ave(self, recalc=False):\\n if self.ave is not None and not recalc:\\n return self.ave\\n\\n self.ave = np.mean(self.img.ravel())\\n return self.ave\",\n \"def get_original_means(self):\\n return self.meanDataValues\",\n \"def avg_e_score(self, entity):\\n return float(entity['es']) / float(entity['count'])\",\n \"def ensemble_mean(self):\\n return self.mean(dim='mem')\",\n \"def get_average_repro(self):\\n return np.mean([agent.get_fledge_probability() for agent in self.agents])\",\n \"def ensemble_mean(self):\\n self.cube = self.cube_ensemble_mean(self.cube)\\n self.processes.append('ensemble_mean')\\n return self.cube\",\n \"def get_average(data):\\n average = sum(data) / len(data)\\n\\n return average\",\n \"def readAvg(self):\\n self.flushInput()\\n\\n if (self.model == 'TDS'):\\n self.write('ACQuire:NUMAVg?\\\\n')\\n return int(self.readline())\\n #elif (self.model == 'GDS'):\\n # FIXME: I'll implement this later. I need to do some\\n # testing, re: whether GDS returns the actual average\\n # number, or log-base-2 of the average number.\",\n \"def get_mean_dict(self):\\n mean = {}\\n for c in self.cellLines:\\n mean[c] = {}\\n for l in self.ligands:\\n mean[c][l] = self.aucs[c][l]['mean']\\n return mean\",\n \"def average(self):\\n return self.summation() / self.count()\",\n \"def annual_average(new_cube):\\n\\n annual_average_cube = new_cube.aggregated_by('year', iris.analysis.MEAN)\\n\\n return annual_average_cube\",\n \"def get_average(self, s_freq, e_freq):\\n s_ind = self.get_bin(s_freq)\\n e_ind = self.get_bin(e_freq)\\n lst = self.mags[s_ind:e_ind+1]\\n try:\\n avg = sum(lst)/len(lst)\\n except:\\n print(s_ind, e_ind)\\n print('werid stuff')\\n avg = 0\\n return avg\",\n \"def get_average_age(self):\\n return np.mean([agent.age for agent in self.agents])\",\n \"def get_mean(self):\\n return self.serie.mean()\",\n \"def gavg(idata):\\n\\t\\n\\twgt1=np.cos(np.deg2rad(idata.lat))*(idata*0+1)\\n\\tga=(wgt1*idata).sum(dim=['lat','lon'])/wgt1.sum(dim=['lat','lon'])\\n\\n\\treturn ga\",\n \"def Mean(data):\\n return data.mean()\",\n \"def _get_mean(self):\\n return [layer._get_mean() for layer in self.layers]\",\n \"def calcAverage(dat):\\n return sum(dat)/len(dat)\",\n \"def slice_avg(self, file_data, slice_range):\\n row_num = 0\\n feature_data = [0] * 7\\n for row in file_data:\\n feature_data[row_num] = sum(row[slice_range[0]:slice_range[1]]) / (slice_range[1] - slice_range[0])\\n row_num += 1\\n self.feature.append(feature_data)\",\n \"def avg(year):\\r\\n df = ouvrir_fichier()\\r\\n df = df.loc[df[\\\"year\\\"].isin([year])]\\r\\n df = df[(\\r\\n df[\\r\\n \\\"emissions\\\"\\r\\n ] == 'Emissions (thousand metric tons of carbon dioxide)'\\r\\n )]\\r\\n print(df)\\r\\n mean_value = df.mean()['value']\\r\\n resultat = {}\\r\\n resultat[\\\"year\\\"] = year\\r\\n resultat['total'] = float(mean_value)\\r\\n print(mean_value)\\r\\n return resultat\",\n \"def average_grade(self):\\n grade_sum = 0\\n grades_length = 0\\n for c in self.courses_grades:\\n if c[1] != \\\"-\\\":\\n grade_sum += int(c[1])\\n grades_length += 1\\n average = grade_sum / grades_length\\n return average\",\n \"def compute_fold_regulation(fc_data_list):\\n # if isinstance(fc_data_list, list):\\n return [{TEST_SAMPLE: fc_elem[TEST_SAMPLE], CONTROL_SAMPLE: fc_elem[CONTROL_SAMPLE],\\n FOLD_REGULATION: fc_elem[FOLD_CHANGE].applymap(lambda x: -1.0/x if x < 1.0 else x)}\\n for fc_elem in fc_data_list]\\n # return fc_data_list.applymap(lambda x: -1.0/x if x < 1.0 else x)\",\n \"def time_average(new_cube):\\n\\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\\n\\n return time_average_cube\",\n \"def _get_average(self):\\n norm = 1.0\\n for pos, idx in enumerate(self.idx):\\n norm *= (self.high[pos] - self.low[pos])\\n return 1.0/norm\",\n \"def average(self):\\n return self.properties.get('average')\",\n \"def get_mean(self):\\n average = self.df[self.col_name].mean()\\n return average\",\n \"def _agg_by_mean(self):\\n return self._data_grouped_by_manufacturer.agg('mean')[['car_value']]\",\n \"def average_length_of_gene(self):\\n return sum([len(e) for e in self.population]) / len(self.population)\",\n \"def get_foldchange(self, exps_for_fc):\\n exp_id_str = get_id_str(self.req_exps)\\n table_name = '%s_datatable_%s' % (self.app_label, exp_id_str)\\n # Make experiment for fold change unique.\\n exps_for_fc = get_unique(exps_for_fc)\\n if not db_table_exists(table_name):\\n self.create_base_table(table_name)\\n column_names = list(get_columnnames(table_name))\\n # Inititialize lists.\\n dividend = [None] * len(exps_for_fc)\\n divisor = [None] * len(exps_for_fc)\\n fc_col_position = [None] * len(exps_for_fc)\\n # Format all columns with scientific notation that end with underscore and a number.\\n datacol_pattern = re.compile(r'_\\\\d+$')\\n for i, column_name in enumerate(column_names):\\n if datacol_pattern.search(column_name) is not None:\\n for j, pair in enumerate(exps_for_fc):\\n pattern = r'_{}$'.format(str(pair['dividend'].id))\\n if re.search(pattern, column_name):\\n if not dividend[j]: \\n dividend[j] = (column_name, pair['dividend'].id,)\\n # For the jth column there will be j columns inserted before that.\\n fc_col_position[j] = i + j\\n elif (str(pair['divisor'].id) in column_name and \\n not divisor[j]):\\n divisor[j] = (column_name, pair['divisor'].id)\\n \\n # Insert the columns for calculating the fold change.\\n for i in range(len(dividend)): \\n fc_col = '{quotient} AS {quotient_name}'.format(\\n quotient=self.wrap_in_func(self.DB_FUNCTION_ZERO, dividend[i][0], divisor[i][0]),\\n quotient_name='\\\"fc_%s/%s\\\"' % (dividend[i][1], divisor[i][1]),\\n )\\n column_names.insert(fc_col_position[i], fc_col)\\n \\n sql = \\\"SELECT %s FROM %s\\\" % (fc_col, table_name)\\n return from_db(sql, fetch_as='tuple')\",\n \"def _compute_cluster_averages(self, key=\\\"_scvi_labels\\\"):\\n # find cell label column\\n label_col = self.adata.uns[\\\"_scvi\\\"][\\\"categorical_mappings\\\"][key][\\\"original_key\\\"]\\n\\n # find data slot\\n x_dict = self.adata.uns[\\\"_scvi\\\"][\\\"data_registry\\\"][\\\"X\\\"]\\n if x_dict[\\\"attr_name\\\"] == \\\"X\\\":\\n use_raw = False\\n else:\\n use_raw = True\\n if x_dict[\\\"attr_name\\\"] == \\\"layers\\\":\\n layer = x_dict[\\\"attr_key\\\"]\\n else:\\n layer = None\\n\\n # compute mean expression of each gene in each cluster/batch\\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\\n\\n return aver\",\n \"def getMeanE(self):\\n\\n\\n\\t\\tEBefore, EAfter = self.getEnergyEvolution()\\n\\n\\t\\tmeanBefore = np.mean(EBefore[-self.__Nkicks//5:])\\n\\t\\tmeanAfter = np.mean(EAfter[-self.__Nkicks//5:])\\n\\t\\tmeanTot = (meanBefore+meanAfter)/2\\n\\n\\t\\treturn meanBefore, meanAfter, meanTot\",\n \"def average_level(self):\\n spl = [utils.dbspl(x) for x in self.load_files()]\\n return np.mean(spl), np.std(spl)\",\n \"def average_matrix(self, groups=[\\\"SP\\\", \\\"SL06\\\", \\\"SL12\\\", \\\"SL24\\\",\\\"SL48\\\", \\\"SL96\\\",\\\"FP06\\\", \\\"FP12\\\", \\\"FP24\\\",\\\"FP48\\\", \\\"FP96\\\", \\\"FL\\\"]):\\n\\n # will only work if genes are columns in matrix\\n revert = False\\n if self._genes_as_rows:\\n self.invert_matrix()\\n revert = True\\n\\n limits = self.reorder_matrix(groups=groups)\\n\\n v = numpy.ones((len(groups),self.genenumber)) # create new array of size (y groups) and (n genes)\\n\\n for g in range(self.genenumber):\\n v[0,g] = numpy.average(self.data_matrix[:limits[0],g])\\n for i in range(len(groups)-1):\\n v[i + 1,g] = numpy.average(self.data_matrix[limits[i]:limits[i + 1],g])\\n\\n self.row_header = groups\\n self.column_header = self.gene_header\\n self.data_matrix = v\\n self.refresh_headers()\\n\\n # if matrix was inverted for gene removal, restore to its previous orientation:\\n if revert:\\n self.invert_matrix()\\n self.averaged = True\",\n \"def calc_average_load (self):\\n #~ self.generation = self.forecast.generation_by_type['generation diesel']\\\\\\n #~ [self.start_year]\\n self.average_load = \\\\\\n self.forecast.yearly_average_diesel_load.ix[self.start_year]\",\n \"def _average_data(self):\\n # TODO: This function looks inefficient - can it be improved?\\n output = np.zeros([self.nints_file, self.ngroups_file,\\n self.rows, self.columns], dtype=self.data.dtype)\\n count = np.zeros([self.nints_file, self.ngroups_file, 1, 1],\\n dtype=self.data.dtype)\\n\\n for intg in range(0, self.nints):\\n intg_file = intg // self.intavg\\n for grp in range(0, self.ngroups):\\n grp_file = grp // self.grpavg\\n output[intg_file, grp_file, :, :] += self.data[intg, grp, :, :]\\n count[intg_file, grp_file, 0, 0] += 1.0\\n\\n # Avoid divide by zero.\\n iszero = np.where(count < 1.0)\\n if iszero:\\n count[iszero] = 1.0\\n output = output / count\\n\\n del count \\n return output\",\n \"def store_overall_means(src_file: H5File) -> None:\\n perp_sum = 0\\n par_sum = 0\\n ref_sum = 0\\n counts = 0\\n for path in rawnav.pump_group_paths(src_file):\\n perp_path = path + '/perp'\\n par_path = path + '/par'\\n ref_path = path + '/ref'\\n perp_sum += src_file[perp_path].attrs['mean']\\n par_sum += src_file[par_path].attrs['mean']\\n ref_sum += src_file[ref_path].attrs['mean']\\n counts += 1\\n src_file.attrs['perp_mean'] = perp_sum / counts\\n src_file.attrs['par_mean'] = par_sum / counts\\n src_file.attrs['ref_mean'] = ref_sum / counts\\n return\",\n \"def avg_added(self):\\n avg = {}\\n for path, lines in self.lines_added.items():\\n avg[path] = round(statistics.mean(lines))\\n\\n return avg\",\n \"def calculateAverage(self): \\n if not self.lastTransferAverage: \\n size=[0,0,0,0]\\n for i in range(0,4):\\n if self.lastTransferredChannel & (1 << i):\\n size[i]=self.lastNbrSamplesPerSeg\\n self.lastAverageArray = [zeros(size[0]),zeros(size[1]),zeros(size[2]),zeros(size[3])]\\n nbrSamp=self.lastNbrSamplesPerSeg\\n for i in range(0,4):\\n if self.lastTransferredChannel & (1 << i):\\n nbrSeg=self.lastNbrSegmentsArray[i]\\n for j in range (0,nbrSamp):\\n for k in range(0,nbrSeg): \\n self.lastAverageArray[i][j]+=self.lastWaveformArray[i][k*nbrSamp+j]\\n self.lastAverageArray[i][j]/=nbrSeg\\n self.lastAverageCalculated=True\\n else: print \\\"NOn averaged data are not available\\\"\",\n \"def _image_average(self, images):\\n image_data = [\\n image.normalize().data for image in images\\n # Workaround: skip partial volcano images at the edges\\n if image.data.shape[0] == image.data.shape[1]\\n ]\\n return np.rint(\\n np.mean(image_data, axis=0)\\n ).astype(np.uint8)\",\n \"def get_mean_accuracy(self):\\n return self.df.correct.mean()\",\n \"def gacha_mean(sourcefile, targetfile):\\n sys.stderr.write(err_msg('Calculating Gacha mean, please wait ...\\\\n'))\\n c = num_char(sourcefile) / num_char(targetfile)\\n sys.stderr.write(err_msg('Gacha mean = ' + str(c) + '\\\\n'))\\n sys.stderr.write(err_msg('Filtering starts ...\\\\n'))\\n return c\",\n \"def per_gene_coverage(genes,df):\\n\\n sub_genes =[]\\n\\n #For every gene in the list, check the average coverage, if less than 100 add it to the final list.\\n for gene in genes:\\n coverage = average(df[df['GeneSymbol;Accession'] == gene]['percentage30'])\\n\\n if coverage < 100:\\n sub_genes.append([gene.split(';')[0],round(coverage,2)])\\n \\n return sub_genes\",\n \"def calc_average_load (self):\\n if self.comp_specs['proposed capacity'] != UNKNOWN:\\n self.average_load = None\\n self.generation = self.forecast.generation['generation diesel']\\\\\\n [self.start_year]\\n self.average_load = \\\\\\n self.forecast.yearly_average_diesel_load.ix[self.start_year]\\n #~ print 'self.average_load',self.average_load\",\n \"def average_strain_data(features, metadata, groups_column='gene_name'):\\n\\n meta_cols = metadata.columns.to_list() \\n data = pd.concat([metadata[groups_column], features], axis=1)\\n mean_data = data.groupby(groups_column).mean()\\n df = metadata.merge(mean_data, how='right', on=groups_column)\\n df = df.groupby(groups_column).first().reset_index()\\n \\n feat = df[[c for c in df.columns if c not in meta_cols]]\\n meta = df[meta_cols]\\n \\n return feat, meta\",\n \"def get_average_MAE(true_pred_df): \\n age_group = true_pred_df.groupby('y_true')\\n \\n mae_average = []\\n for age, age_data in age_group:\\n mae_average.append(np.mean(age_data.mae))\\n \\n return mae_average\",\n \"def _get_mean(self):\\n return self._get_conditional_negative_energy()\",\n \"def get_stats(self, gene, groups=[\\\"SP\\\", \\\"SL06\\\", \\\"SL12\\\", \\\"SL24\\\",\\\"SL48\\\", \\\"SL96\\\",\\\"FP06\\\", \\\"FP12\\\", \\\"FP24\\\",\\\"FP48\\\", \\\"FP96\\\", \\\"FL\\\"]):\\n\\n try:\\n pos = self.gene_header.index(gene)\\n except:\\n return [],[]\\n\\n limits = [0] + self.reorder_matrix(groups=groups)\\n #print limits\\n intervals = zip(limits[:-1],limits[1:])\\n print \\\"Debugging: ave and stdev:-\\\"\\n #print intervals\\n #print self.data_matrix\\n #print self.data_matrix[:,pos]\\n #print [ (self.data_matrix[ i:j,pos ]) for i,j in intervals]\\n ave = [ numpy.average(self.data_matrix[ i:j,pos ]) for i,j in intervals]\\n print ave\\n stdev = [ numpy.std(self.data_matrix[ i:j,pos ]) for i,j in intervals]\\n print stdev\\n return ave, stdev\",\n \"def average(data):\\r\\n sum =0\\r\\n for i in data:\\r\\n sum+=i\\r\\n return sum/len(data)\",\n \"def averaged_risk(self):\\n return self._averaged_risk\",\n \"def averaged_risk(self):\\n return self._averaged_risk\",\n \"def ensemble_perts(self):\\n #emean = self.ensemble_mean()\\n return self - self.ensemble_mean()\\n #return self.state.values\",\n \"def get_average_mark(self, test):\\n return\",\n \"def run(self, data):\\n for idx, block in enumerate(data):\\n current = float(np.mean(block['current']['value']))\\n print(f'{idx}: {current}')\",\n \"def mean_calc(data, col):\\n\\tm = sum([row[col] for row in data]) / len(data)\\n\\treturn m\",\n \"def average(self):\\n return np.mean(self.buf[:self._size], axis=0)\",\n \"def average_population_grade(population):\\r\\n total = 0\\r\\n for individual in population :\\r\\n total += get_individual_fitness(individual)\\r\\n return total/POPULATION_COUNT\",\n \"def compute_averaged_values(filenames, cols, skip=0, stop=-1, column_major=False, separator='[\\\\t ]'):\\n\\n # Read columns\\n all_cols = read_file_lines(filenames, cols, skip, stop, column_major, separator)\\n\\n # Initialise results array\\n res = [np.zeros(len(i)) for i in all_cols[0]]\\n\\n # For each set of columns\\n for file_data in all_cols:\\n # For each column of the file\\n for num, col in enumerate(file_data):\\n # Add the value divided by the amount of files considered (to get the average)\\n res[num] += col/len(all_cols)\\n\\n return res\",\n \"def test_liemdframe_get_average(self):\\n\\n ave = self.mdframe.get_average()\\n\\n # Unbound energies should be same value for all poses\\n self.assertEqual(len(ave['coul_unbound'].unique()), 1)\\n self.assertEqual(len(ave['coul_unbound']), 5)\\n self.assertEqual(len(ave['vdw_unbound'].unique()), 1)\\n self.assertEqual(len(ave['vdw_unbound']), 5)\\n\\n # Bound energies mostly unique for all poses\\n self.assertEqual(len(ave['coul'].unique()), 5)\\n self.assertEqual(len(ave['vdw'].unique()), 5)\\n self.assertEqual(len(ave['coul']), 5)\\n self.assertEqual(len(ave['vdw']), 5)\\n\\n # Check values\\n self.assertListEqual(list(ave.poses), [1, 2, 3, 4, 5])\\n self.assertListEqual(list(ave.cases), [1])\\n self.assertAlmostEqual(ave['coul'][0], 60.12452, places=5)\\n self.assertAlmostEqual(ave['vdw'][1], -53.78007, places=5)\",\n \"def calculate_mean(data_dir):\\n data = ([each for each in os.listdir(data_dir)\\n if each.endswith('.h5')])\\n all_data = []\\n for num_data in data:\\n processed_data = os.path.join(data_dir, num_data)\\n file = h5py.File(processed_data, 'r') \\n data = file.get('Processed_data') \\n all_data.append(data)\\n all_data = np.array(all_data)\\n all_data = np.mean(all_data, axis=0)\\n return all_data\",\n \"def compute_GS(GMtcs):\\n\\n GS = np.mean(GMtcs,axis=0) #average over voxels\\n\\n return GS\",\n \"def get_rolling_mean_provenance(self, suptitle, ancestor_files):\\n suptitle = suptitle.replace('\\\\n', '')\\n caption = (f\\\"{suptitle}. For CMIP5 (\\\"\\n f\\\"{self.formatter(f'cmip5-{self.scenarios[0]}')}, \\\"\\n f\\\"{self.formatter(f'cmip5-{self.scenarios[1]}')} and \\\"\\n f\\\"{self.formatter(f'cmip5-{self.scenarios[2]}')}) \\\"\\n f\\\"and CMIP6 \\\"\\n f\\\"({self.formatter(f'cmip6-{self.scenarios[0]}')}, \\\"\\n f\\\"{self.formatter(f'cmip6-{self.scenarios[1]}')} and \\\"\\n f\\\"{self.formatter(f'cmip6-{self.scenarios[2]}')})\\\")\\n\\n record = {\\n 'caption': caption,\\n 'statistics': ['anomaly', \\\"other\\\"],\\n 'domains': ['reg', 'global'],\\n 'plot_types': ['scatter', 'line', 'times'],\\n 'authors': [\\n 'cos_josep',\\n ],\\n 'references': [\\n 'cos22esd',\\n ],\\n 'ancestors': ancestor_files,\\n }\\n return record\",\n \"def average_emission(data: List[EmissionPerCapita], current_year: int) -> float:\\r\\n\\r\\n index = current_year - data[0].start_year # get the index for current year\\r\\n\\r\\n # Get all emissions from that year.\\r\\n current_year_emissions = []\\r\\n for countries in data:\\r\\n current_year_emissions.append(countries.epc_year[index])\\r\\n\\r\\n average = sum(current_year_emissions) / len(data)\\r\\n return average\",\n \"def mean_height(data):\",\n \"def mean_height(data):\",\n \"def average_age():\\n df = pd.read_csv(config.META_FQN, sep=\\\"\\\\t\\\")\\n ages = []\\n for _, row in df.iterrows():\\n if row[\\\"asr_test\\\"]:\\n age = row[\\\"Age_ses1\\\"]\\n if not math.isnan(age):\\n ages.append(age)\\n\\n print(\\\"------ Age ------\\\")\\n print_stats(ages)\",\n \"def mean(self):\\n return self._summarize(lambda c: c.mean)\",\n \"def average(self, returns):\\r\\n return returns.mean() * self.day\",\n \"def _compute_mean(self, C, mag, rjb, rake):\\n mean = (C['a1'] +\\n self._compute_linear_magnitude_term(C, mag) +\\n self._compute_quadratic_magnitude_term(C, mag) +\\n self._compute_logarithmic_distance_term(C, mag, rjb) +\\n self._compute_faulting_style_term(C, rake))\\n\\n return mean\",\n \"def _get_mean(self):\\n return (0.485, 0.456, 0.406)\",\n \"def print_avg():\",\n \"def test_mean_div(self):\\n gfile = grades.writers.GradesFile(self.fname)\\n gfile.table.compute_mean()\\n gfile.table_format = 'org'\\n self.check_output(self.output_str3, gfile, div_on=('Group', 'Test 1'))\",\n \"def global_mean(self):\\n return self.interaction_data.label.mean()\",\n \"def get_average(self, samples=50):\\n first = self.layers[0].load_image()\\n res = np.zeros(first.shape, dtype=float)\\n intervals = len(self.layers)/samples\\n for l in self.layers[::int(intervals)]:\\n img = l.load_image().astype(float)\\n res += img\\n l.image = None\\n return samples**-1*res\",\n \"def get_avg_f1(ccs):\\n scorers = ccs.scorers\\n f1_scores = []\\n for scorer in scorers:\\n f1_scores.append(scorer.get_f1())\\n\\n avg_f1 = 100 * np.average(f1_scores)\\n\\n return avg_f1\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def get_average_torsion (phis) :\\n shift = phis[0]\\n phis_shifted = get_diffvec(phis,shift)\\n avg_shifted = phis_shifted.sum()/len(phis)\\n average = avg_shifted + shift\\n return average\",\n \"def get_average_torsion (phis) :\\n shift = phis[0]\\n phis_shifted = get_diffvec(phis,shift)\\n avg_shifted = phis_shifted.sum()/len(phis)\\n average = avg_shifted + shift\\n return average\",\n \"def mpg_by_make(self):\\n ## create reference dict and aggregated dict\\n reference_mpgs = defaultdict(list)\\n make_avg_mpgs = defaultdict(str)\\n ## loop through the data and add to both dicts\\n for auto in self.data:\\n ## get the year\\n the_make = auto.make\\n ## maintain a list of mpgs for each key=make\\n reference_mpgs[the_make].append(auto.mpg)\\n ## update the cumulative mpg as we read auto objects\\n make_avg_mpgs[the_make] = sum(reference_mpgs[the_make]) / len(reference_mpgs[the_make])\\n return make_avg_mpgs\",\n \"def calculate_mean_dark(data_dir):\\n\\n data = ([each for each in os.listdir(data_dir)\\n if each.endswith('.h5')])\\n \\n all_data = []\\n for num_data in data:\\n #print(num_data)\\n processed_data = os.path.join(data_dir, num_data)\\n file = h5py.File(processed_data, 'r') \\n data = file.get('Processed_data')\\n all_data.append(data)\\n #print\\n\\n all_data = np.array(all_data)\\n all_data = np.mean(all_data, axis=0)\\n return all_data\",\n \"def cf_mean(self):\\n net_power = self['annual_gross_energy'] \\\\\\n - self['annual_thermal_consumption'] # kW-hr\\n # q_pb_des is in MW, convert to kW-hr\\n name_plate = self['q_pb_design'] * 8760 * 1000\\n\\n return net_power / name_plate\",\n \"def get_averages(self):\\t\\n\\t\\t\\n\\t\\taverages = {}\\n\\t\\tfor subject in self.grades.iterkeys():\\n\\t\\t\\taverages[subject] = float(sum(self.grades[subject])) / len(self.grades[subject])\\n\\t\\treturn averages\",\n \"def clr_trans(data):\\n if isinstance(data, pd.DataFrame):\\n data = data.to_numpy()\\n data[data == 0] = 1/len(data[0,:])**2 # replace zeros with small constant\\n geometric_mean = mstats.gmean(data,axis=1)\\n clr_data = np.log(data / geometric_mean[:,None])\\n return clr_data\",\n \"def average(data, event):\\n if len(data) == 0:\\n return 0\\n\\n score = 0\\n # scores = []\\n count = 0\\n for i in data:\\n count += 1\\n if event == 'Swim' or event == 'Run':\\n num = time_seconds(i[event])\\n #print(\\\"first if\\\")\\n #Sprint(num)\\n else:\\n num = int(i[event])\\n #print(\\\"second if\\\")\\n #print(num)\\n #scores[count] =\\n #print(\\\"end of loop count\\\" + str(count))\\n score += num\\n #print (\\\"score\\\" + str(score))\\n\\n # total = 0\\n # for x in range(0,len(scores)):\\n # total += scores[x]\\n score = float(score)\\n\\n return score / count\",\n \"def calccalmean(self,blk):\\n calind=self.getcalind(blk)\\n x=self.spec[calind,:]\\n return np.nanmean(x,axis=0)\",\n \"def average(X, ebunch):\\n edge_embeds = np.zeros((len(ebunch), len(X[list(X.keys())[0]])))\\n i = 0\\n for edge in ebunch:\\n edge_embeds[i] = (X[str(edge[0])] + X[str(edge[1])]) / 2.0\\n i += 1\\n return edge_embeds\",\n \"def get_mean(self):\\n raise NotImplementedError(\\\"This is an abstract method and needs to be implemented in derived classes.\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56925446","0.5640803","0.54428434","0.5386881","0.53427356","0.5342548","0.5336942","0.53117526","0.528858","0.5283458","0.5280344","0.5261843","0.52486813","0.5230886","0.5226844","0.52136445","0.51920736","0.51852506","0.5177504","0.51448035","0.51356715","0.51343775","0.5132684","0.51232564","0.5072062","0.50660586","0.5058109","0.5055375","0.5044818","0.50379753","0.50336945","0.50329006","0.5029577","0.502814","0.5026619","0.50194216","0.5012141","0.50078785","0.49972135","0.4994736","0.4992615","0.4992532","0.49843755","0.4980682","0.49707937","0.49692103","0.49673423","0.49660754","0.49590155","0.49492675","0.4940826","0.49210086","0.49157038","0.49141315","0.49139506","0.4903874","0.48995665","0.48955542","0.48773614","0.48773614","0.48755878","0.48713005","0.48660028","0.48613006","0.48601693","0.4851041","0.48491645","0.48473266","0.48455968","0.48432747","0.4837426","0.48356664","0.48283964","0.48283964","0.48158845","0.48105818","0.48062775","0.47926155","0.47916237","0.47874403","0.47843277","0.47819299","0.4775783","0.47754097","0.47740665","0.47740665","0.47740665","0.47740665","0.47740665","0.47694352","0.47694352","0.47690862","0.47665504","0.47653556","0.47648698","0.47618333","0.47598583","0.4758794","0.4757676","0.47529355"],"string":"[\n \"0.56925446\",\n \"0.5640803\",\n \"0.54428434\",\n \"0.5386881\",\n \"0.53427356\",\n \"0.5342548\",\n \"0.5336942\",\n \"0.53117526\",\n \"0.528858\",\n \"0.5283458\",\n \"0.5280344\",\n \"0.5261843\",\n \"0.52486813\",\n \"0.5230886\",\n \"0.5226844\",\n \"0.52136445\",\n \"0.51920736\",\n \"0.51852506\",\n \"0.5177504\",\n \"0.51448035\",\n \"0.51356715\",\n \"0.51343775\",\n \"0.5132684\",\n \"0.51232564\",\n \"0.5072062\",\n \"0.50660586\",\n \"0.5058109\",\n \"0.5055375\",\n \"0.5044818\",\n \"0.50379753\",\n \"0.50336945\",\n \"0.50329006\",\n \"0.5029577\",\n \"0.502814\",\n \"0.5026619\",\n \"0.50194216\",\n \"0.5012141\",\n \"0.50078785\",\n \"0.49972135\",\n \"0.4994736\",\n \"0.4992615\",\n \"0.4992532\",\n \"0.49843755\",\n \"0.4980682\",\n \"0.49707937\",\n \"0.49692103\",\n \"0.49673423\",\n \"0.49660754\",\n \"0.49590155\",\n \"0.49492675\",\n \"0.4940826\",\n \"0.49210086\",\n \"0.49157038\",\n \"0.49141315\",\n \"0.49139506\",\n \"0.4903874\",\n \"0.48995665\",\n \"0.48955542\",\n \"0.48773614\",\n \"0.48773614\",\n \"0.48755878\",\n \"0.48713005\",\n \"0.48660028\",\n \"0.48613006\",\n \"0.48601693\",\n \"0.4851041\",\n \"0.48491645\",\n \"0.48473266\",\n \"0.48455968\",\n \"0.48432747\",\n \"0.4837426\",\n \"0.48356664\",\n \"0.48283964\",\n \"0.48283964\",\n \"0.48158845\",\n \"0.48105818\",\n \"0.48062775\",\n \"0.47926155\",\n \"0.47916237\",\n \"0.47874403\",\n \"0.47843277\",\n \"0.47819299\",\n \"0.4775783\",\n \"0.47754097\",\n \"0.47740665\",\n \"0.47740665\",\n \"0.47740665\",\n \"0.47740665\",\n \"0.47740665\",\n \"0.47694352\",\n \"0.47694352\",\n \"0.47690862\",\n \"0.47665504\",\n \"0.47653556\",\n \"0.47648698\",\n \"0.47618333\",\n \"0.47598583\",\n \"0.4758794\",\n \"0.4757676\",\n \"0.47529355\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52104104"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":12881,"cells":{"query":{"kind":"string","value":"Get fold change averaged data for gene. This is useful as it formats data for input into copasi"},"document":{"kind":"string","value":"def get_data_copasi_style_dct(self, gene, cell_line='A', plot=False, new_name=None,\n filename=None, indep_dct=None):\n if gene not in self.genes:\n raise ValueError('{} is not in list of genes \"{}\"'.format(gene, self.genes))\n treat = self.treatment_data.query('cell_line == \"{}\" and Assay == \"{}\"'.format(cell_line, gene))['dct']\n treat.index = treat.index.droplevel('Assay')\n # treat = pandas.pivot_table(treat, index=['cell_line', 'treatment', 'replicate'], columns='time')\n treat = treat.groupby(level=['cell_line', 'treatment']).aggregate(numpy.mean).transpose()[cell_line]\n\n base = self.baseline_data.query('cell_line == \"{}\" and Assay == \"{}\"'.format(cell_line, gene))['dct']\n\n base = base.groupby(level=['cell_line', 'treatment']).aggregate(numpy.mean).transpose()[cell_line]\n baseline0 = pandas.DataFrame(base)['Baseline'][0]\n control = pandas.DataFrame(treat['Control'])\n tgf = pandas.DataFrame(treat['TGFb'])\n control.loc[0] = baseline0\n tgf.loc[0] = baseline0\n if new_name is not None:\n control.columns = [new_name]\n tgf.columns = [new_name]\n gene = new_name\n\n else:\n control.columns = [gene]\n tgf.columns = [gene]\n\n\n\n control = control.sort_index(level=0)\n tgf = tgf.sort_index(level=0)\n\n control = control.reset_index()\n tgf = tgf.reset_index()\n\n control['time'] = control['time'] * 60\n tgf['time'] = tgf['time'] * 60\n\n if indep_dct is not None:\n if len(indep_dct) != 2:\n raise ValueError('len of indep_dct should be 2 for this function. First key should be Control second TGFb')\n\n if 'Control' not in indep_dct.keys():\n raise ValueError\n\n if 'TGFb' not in indep_dct.keys():\n raise ValueError\n\n for i in indep_dct['Control']:\n if i[-6:] != '_indep':\n raise ValueError('Keys in indep_dct shuold have _indep as suffix')\n\n if indep_dct['Control'][i] == '0_time_point_indep':\n control[i] = float(control.loc[0, gene])\n\n else:\n control[i] = indep_dct['Control'][i]\n\n for i in indep_dct['TGFb']:\n if i[-6:] != '_indep':\n raise ValueError('Keys in indep_dct shuold have _indep as suffix')\n\n if indep_dct['TGFb'][i] == '0_time_point_indep':\n tgf[i] = float(tgf.loc[0, gene])\n\n else:\n tgf[i] = indep_dct['TGFb'][i]\n\n\n # tgf[i] = indep_dct['TGFb'][i]\n\n if filename is not None:\n ctrl_filename = \"{}{}.txt\".format(filename[:-4], '_control')\n tgf_filename = \"{}{}.txt\".format(filename[:-4], '_tgfb')\n control.to_csv(ctrl_filename, sep='\\t', index=False)\n tgf.to_csv(tgf_filename, sep='\\t', index=False)\n\n if plot:\n seaborn.set_context('talk', font_scale=2)\n seaborn.set_style('white')\n fig, ax = plt.subplots()\n plt.plot(tgf.time/60, tgf[gene], label='tgf', marker='o')\n plt.plot(control.time/60, control[gene], label='control', marker='o')\n plt.xlabel('Time(h)')\n plt.ylabel('dct')\n plt.legend(loc='best')\n seaborn.despine(fig=fig, top=True, right=True)\n plt.title('{}, {}'.format(g, cell_line))\n\n plt.show()\n\n return control, tgf"},"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 load_average(self):\n return _favg(self.load_samples)","def get_mean(self):\n mean = np.array(np.zeros((4,8)))\n for i,c in enumerate(self.cellLines):\n for j,l in enumerate(self.ligands):\n mean[i][j] = self.aucs[c][l]['mean']\n return mean","def mean_ensembler(self):\n models_name = self._get_models_name(self.data_dir)\n if type(models_name) != list:\n models_name = [models_name]\n\n get_test_y = self._get_model_val(models_name, self.data_dir, 'test')\n # Calculate the average\n average = pd.DataFrame()\n for add in list(get_test_y.keys()):\n if average.empty:\n average[self.TAGS] = get_test_y[add][self.TAGS]\n else:\n average[self.TAGS] += get_test_y[add][self.TAGS]\n\n average = average/len(list(get_test_y.keys()))\n average.insert(loc=0, column='id', value=self.test_id.values)\n doc_name = self.data_dir + '/' + 'submission_average_ensembler.csv'\n average.to_csv(doc_name, index=False)\n print('submission file saved at {}'.format(doc_name))\n return average","def _ave(self):\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def _ave(self):\n\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()","def get_average(self):\n self.avg = math.floor((self.maths + self.phy + self.che) / 3, )\n self.assign_grade()\n return self.avg\n # End of method get_average","def get_mean(self):\r\n for i in range(1,len(self.data[0])):\r\n self.prom.append(np.mean(self.data[:,i]))","def ensemble_mean(self):\n new_cubelist = []\n for cube in self.cubelist:\n new_cubelist.append(self.cube_ensemble_mean(cube))\n self.cubelist = iris.cube.CubeList(new_cubelist)\n self.processes.append('ensemble_mean')\n return self.cubelist","def getAvg(self):\r\n\t\treturn self.data['avg']","def average(data):\n return np.average(data)","def get_ave(self, recalc=False):\n if self.ave is not None and not recalc:\n return self.ave\n\n self.ave = np.mean(self.img.ravel())\n return self.ave","def get_original_means(self):\n return self.meanDataValues","def avg_e_score(self, entity):\n return float(entity['es']) / float(entity['count'])","def ensemble_mean(self):\n return self.mean(dim='mem')","def get_average_repro(self):\n return np.mean([agent.get_fledge_probability() for agent in self.agents])","def ensemble_mean(self):\n self.cube = self.cube_ensemble_mean(self.cube)\n self.processes.append('ensemble_mean')\n return self.cube","def get_data_copasi_style_d3ct(self, gene, cell_line='A', plot=False, new_name=None,\n filename=None, indep_dct=None):\n if gene not in self.genes:\n raise ValueError('{} is not in list of genes \"{}\"'.format(gene, self.genes))\n df = self.d3ct.query('cell_line == \"{}\" and Assay == \"{}\"'.format(cell_line, gene))\n df = pandas.pivot_table(df, values=0, index=['cell_line', 'replicate'], columns='time')\n mean = df.mean(axis=0)\n if new_name is not None:\n mean = pandas.DataFrame(mean, columns=[new_name])\n else:\n mean = pandas.DataFrame(mean, columns=[gene])\n\n mean = mean.reset_index()\n mean['time'] = mean['time']*60\n mean.loc[0] = [0, 0]\n\n if indep_dct is not None:\n for i in indep_dct:\n if i[-5:] != '_indep':\n raise ValueError('Keys in indep_dct shuold have _indep as suffix')\n\n mean[i] = indep_dct[i]\n\n if filename is not None:\n mean.to_csv(filename, sep='\\t', index=False)\n\n if plot:\n mean.plot(x='time')\n plt.show()\n\n return mean","def get_average(data):\n average = sum(data) / len(data)\n\n return average","def readAvg(self):\n self.flushInput()\n\n if (self.model == 'TDS'):\n self.write('ACQuire:NUMAVg?\\n')\n return int(self.readline())\n #elif (self.model == 'GDS'):\n # FIXME: I'll implement this later. I need to do some\n # testing, re: whether GDS returns the actual average\n # number, or log-base-2 of the average number.","def get_mean_dict(self):\n mean = {}\n for c in self.cellLines:\n mean[c] = {}\n for l in self.ligands:\n mean[c][l] = self.aucs[c][l]['mean']\n return mean","def average(self):\n return self.summation() / self.count()","def annual_average(new_cube):\n\n annual_average_cube = new_cube.aggregated_by('year', iris.analysis.MEAN)\n\n return annual_average_cube","def get_average(self, s_freq, e_freq):\n s_ind = self.get_bin(s_freq)\n e_ind = self.get_bin(e_freq)\n lst = self.mags[s_ind:e_ind+1]\n try:\n avg = sum(lst)/len(lst)\n except:\n print(s_ind, e_ind)\n print('werid stuff')\n avg = 0\n return avg","def get_average_age(self):\n return np.mean([agent.age for agent in self.agents])","def get_mean(self):\n return self.serie.mean()","def gavg(idata):\n\t\n\twgt1=np.cos(np.deg2rad(idata.lat))*(idata*0+1)\n\tga=(wgt1*idata).sum(dim=['lat','lon'])/wgt1.sum(dim=['lat','lon'])\n\n\treturn ga","def Mean(data):\n return data.mean()","def _get_mean(self):\n return [layer._get_mean() for layer in self.layers]","def calcAverage(dat):\n return sum(dat)/len(dat)","def slice_avg(self, file_data, slice_range):\n row_num = 0\n feature_data = [0] * 7\n for row in file_data:\n feature_data[row_num] = sum(row[slice_range[0]:slice_range[1]]) / (slice_range[1] - slice_range[0])\n row_num += 1\n self.feature.append(feature_data)","def avg(year):\r\n df = ouvrir_fichier()\r\n df = df.loc[df[\"year\"].isin([year])]\r\n df = df[(\r\n df[\r\n \"emissions\"\r\n ] == 'Emissions (thousand metric tons of carbon dioxide)'\r\n )]\r\n print(df)\r\n mean_value = df.mean()['value']\r\n resultat = {}\r\n resultat[\"year\"] = year\r\n resultat['total'] = float(mean_value)\r\n print(mean_value)\r\n return resultat","def compute_fold_regulation(fc_data_list):\n # if isinstance(fc_data_list, list):\n return [{TEST_SAMPLE: fc_elem[TEST_SAMPLE], CONTROL_SAMPLE: fc_elem[CONTROL_SAMPLE],\n FOLD_REGULATION: fc_elem[FOLD_CHANGE].applymap(lambda x: -1.0/x if x < 1.0 else x)}\n for fc_elem in fc_data_list]\n # return fc_data_list.applymap(lambda x: -1.0/x if x < 1.0 else x)","def average_grade(self):\n grade_sum = 0\n grades_length = 0\n for c in self.courses_grades:\n if c[1] != \"-\":\n grade_sum += int(c[1])\n grades_length += 1\n average = grade_sum / grades_length\n return average","def time_average(new_cube):\n\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\n\n return time_average_cube","def _get_average(self):\n norm = 1.0\n for pos, idx in enumerate(self.idx):\n norm *= (self.high[pos] - self.low[pos])\n return 1.0/norm","def average(self):\n return self.properties.get('average')","def get_mean(self):\n average = self.df[self.col_name].mean()\n return average","def _agg_by_mean(self):\n return self._data_grouped_by_manufacturer.agg('mean')[['car_value']]","def average_length_of_gene(self):\n return sum([len(e) for e in self.population]) / len(self.population)","def get_foldchange(self, exps_for_fc):\n exp_id_str = get_id_str(self.req_exps)\n table_name = '%s_datatable_%s' % (self.app_label, exp_id_str)\n # Make experiment for fold change unique.\n exps_for_fc = get_unique(exps_for_fc)\n if not db_table_exists(table_name):\n self.create_base_table(table_name)\n column_names = list(get_columnnames(table_name))\n # Inititialize lists.\n dividend = [None] * len(exps_for_fc)\n divisor = [None] * len(exps_for_fc)\n fc_col_position = [None] * len(exps_for_fc)\n # Format all columns with scientific notation that end with underscore and a number.\n datacol_pattern = re.compile(r'_\\d+$')\n for i, column_name in enumerate(column_names):\n if datacol_pattern.search(column_name) is not None:\n for j, pair in enumerate(exps_for_fc):\n pattern = r'_{}$'.format(str(pair['dividend'].id))\n if re.search(pattern, column_name):\n if not dividend[j]: \n dividend[j] = (column_name, pair['dividend'].id,)\n # For the jth column there will be j columns inserted before that.\n fc_col_position[j] = i + j\n elif (str(pair['divisor'].id) in column_name and \n not divisor[j]):\n divisor[j] = (column_name, pair['divisor'].id)\n \n # Insert the columns for calculating the fold change.\n for i in range(len(dividend)): \n fc_col = '{quotient} AS {quotient_name}'.format(\n quotient=self.wrap_in_func(self.DB_FUNCTION_ZERO, dividend[i][0], divisor[i][0]),\n quotient_name='\"fc_%s/%s\"' % (dividend[i][1], divisor[i][1]),\n )\n column_names.insert(fc_col_position[i], fc_col)\n \n sql = \"SELECT %s FROM %s\" % (fc_col, table_name)\n return from_db(sql, fetch_as='tuple')","def _compute_cluster_averages(self, key=\"_scvi_labels\"):\n # find cell label column\n label_col = self.adata.uns[\"_scvi\"][\"categorical_mappings\"][key][\"original_key\"]\n\n # find data slot\n x_dict = self.adata.uns[\"_scvi\"][\"data_registry\"][\"X\"]\n if x_dict[\"attr_name\"] == \"X\":\n use_raw = False\n else:\n use_raw = True\n if x_dict[\"attr_name\"] == \"layers\":\n layer = x_dict[\"attr_key\"]\n else:\n layer = None\n\n # compute mean expression of each gene in each cluster/batch\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\n\n return aver","def average_level(self):\n spl = [utils.dbspl(x) for x in self.load_files()]\n return np.mean(spl), np.std(spl)","def getMeanE(self):\n\n\n\t\tEBefore, EAfter = self.getEnergyEvolution()\n\n\t\tmeanBefore = np.mean(EBefore[-self.__Nkicks//5:])\n\t\tmeanAfter = np.mean(EAfter[-self.__Nkicks//5:])\n\t\tmeanTot = (meanBefore+meanAfter)/2\n\n\t\treturn meanBefore, meanAfter, meanTot","def average_matrix(self, groups=[\"SP\", \"SL06\", \"SL12\", \"SL24\",\"SL48\", \"SL96\",\"FP06\", \"FP12\", \"FP24\",\"FP48\", \"FP96\", \"FL\"]):\n\n # will only work if genes are columns in matrix\n revert = False\n if self._genes_as_rows:\n self.invert_matrix()\n revert = True\n\n limits = self.reorder_matrix(groups=groups)\n\n v = numpy.ones((len(groups),self.genenumber)) # create new array of size (y groups) and (n genes)\n\n for g in range(self.genenumber):\n v[0,g] = numpy.average(self.data_matrix[:limits[0],g])\n for i in range(len(groups)-1):\n v[i + 1,g] = numpy.average(self.data_matrix[limits[i]:limits[i + 1],g])\n\n self.row_header = groups\n self.column_header = self.gene_header\n self.data_matrix = v\n self.refresh_headers()\n\n # if matrix was inverted for gene removal, restore to its previous orientation:\n if revert:\n self.invert_matrix()\n self.averaged = True","def calc_average_load (self):\n #~ self.generation = self.forecast.generation_by_type['generation diesel']\\\n #~ [self.start_year]\n self.average_load = \\\n self.forecast.yearly_average_diesel_load.ix[self.start_year]","def _average_data(self):\n # TODO: This function looks inefficient - can it be improved?\n output = np.zeros([self.nints_file, self.ngroups_file,\n self.rows, self.columns], dtype=self.data.dtype)\n count = np.zeros([self.nints_file, self.ngroups_file, 1, 1],\n dtype=self.data.dtype)\n\n for intg in range(0, self.nints):\n intg_file = intg // self.intavg\n for grp in range(0, self.ngroups):\n grp_file = grp // self.grpavg\n output[intg_file, grp_file, :, :] += self.data[intg, grp, :, :]\n count[intg_file, grp_file, 0, 0] += 1.0\n\n # Avoid divide by zero.\n iszero = np.where(count < 1.0)\n if iszero:\n count[iszero] = 1.0\n output = output / count\n\n del count \n return output","def store_overall_means(src_file: H5File) -> None:\n perp_sum = 0\n par_sum = 0\n ref_sum = 0\n counts = 0\n for path in rawnav.pump_group_paths(src_file):\n perp_path = path + '/perp'\n par_path = path + '/par'\n ref_path = path + '/ref'\n perp_sum += src_file[perp_path].attrs['mean']\n par_sum += src_file[par_path].attrs['mean']\n ref_sum += src_file[ref_path].attrs['mean']\n counts += 1\n src_file.attrs['perp_mean'] = perp_sum / counts\n src_file.attrs['par_mean'] = par_sum / counts\n src_file.attrs['ref_mean'] = ref_sum / counts\n return","def avg_added(self):\n avg = {}\n for path, lines in self.lines_added.items():\n avg[path] = round(statistics.mean(lines))\n\n return avg","def calculateAverage(self): \n if not self.lastTransferAverage: \n size=[0,0,0,0]\n for i in range(0,4):\n if self.lastTransferredChannel & (1 << i):\n size[i]=self.lastNbrSamplesPerSeg\n self.lastAverageArray = [zeros(size[0]),zeros(size[1]),zeros(size[2]),zeros(size[3])]\n nbrSamp=self.lastNbrSamplesPerSeg\n for i in range(0,4):\n if self.lastTransferredChannel & (1 << i):\n nbrSeg=self.lastNbrSegmentsArray[i]\n for j in range (0,nbrSamp):\n for k in range(0,nbrSeg): \n self.lastAverageArray[i][j]+=self.lastWaveformArray[i][k*nbrSamp+j]\n self.lastAverageArray[i][j]/=nbrSeg\n self.lastAverageCalculated=True\n else: print \"NOn averaged data are not available\"","def _image_average(self, images):\n image_data = [\n image.normalize().data for image in images\n # Workaround: skip partial volcano images at the edges\n if image.data.shape[0] == image.data.shape[1]\n ]\n return np.rint(\n np.mean(image_data, axis=0)\n ).astype(np.uint8)","def get_mean_accuracy(self):\n return self.df.correct.mean()","def gacha_mean(sourcefile, targetfile):\n sys.stderr.write(err_msg('Calculating Gacha mean, please wait ...\\n'))\n c = num_char(sourcefile) / num_char(targetfile)\n sys.stderr.write(err_msg('Gacha mean = ' + str(c) + '\\n'))\n sys.stderr.write(err_msg('Filtering starts ...\\n'))\n return c","def per_gene_coverage(genes,df):\n\n sub_genes =[]\n\n #For every gene in the list, check the average coverage, if less than 100 add it to the final list.\n for gene in genes:\n coverage = average(df[df['GeneSymbol;Accession'] == gene]['percentage30'])\n\n if coverage < 100:\n sub_genes.append([gene.split(';')[0],round(coverage,2)])\n \n return sub_genes","def calc_average_load (self):\n if self.comp_specs['proposed capacity'] != UNKNOWN:\n self.average_load = None\n self.generation = self.forecast.generation['generation diesel']\\\n [self.start_year]\n self.average_load = \\\n self.forecast.yearly_average_diesel_load.ix[self.start_year]\n #~ print 'self.average_load',self.average_load","def get_average_MAE(true_pred_df): \n age_group = true_pred_df.groupby('y_true')\n \n mae_average = []\n for age, age_data in age_group:\n mae_average.append(np.mean(age_data.mae))\n \n return mae_average","def average_strain_data(features, metadata, groups_column='gene_name'):\n\n meta_cols = metadata.columns.to_list() \n data = pd.concat([metadata[groups_column], features], axis=1)\n mean_data = data.groupby(groups_column).mean()\n df = metadata.merge(mean_data, how='right', on=groups_column)\n df = df.groupby(groups_column).first().reset_index()\n \n feat = df[[c for c in df.columns if c not in meta_cols]]\n meta = df[meta_cols]\n \n return feat, meta","def _get_mean(self):\n return self._get_conditional_negative_energy()","def get_stats(self, gene, groups=[\"SP\", \"SL06\", \"SL12\", \"SL24\",\"SL48\", \"SL96\",\"FP06\", \"FP12\", \"FP24\",\"FP48\", \"FP96\", \"FL\"]):\n\n try:\n pos = self.gene_header.index(gene)\n except:\n return [],[]\n\n limits = [0] + self.reorder_matrix(groups=groups)\n #print limits\n intervals = zip(limits[:-1],limits[1:])\n print \"Debugging: ave and stdev:-\"\n #print intervals\n #print self.data_matrix\n #print self.data_matrix[:,pos]\n #print [ (self.data_matrix[ i:j,pos ]) for i,j in intervals]\n ave = [ numpy.average(self.data_matrix[ i:j,pos ]) for i,j in intervals]\n print ave\n stdev = [ numpy.std(self.data_matrix[ i:j,pos ]) for i,j in intervals]\n print stdev\n return ave, stdev","def average(data):\r\n sum =0\r\n for i in data:\r\n sum+=i\r\n return sum/len(data)","def averaged_risk(self):\n return self._averaged_risk","def averaged_risk(self):\n return self._averaged_risk","def ensemble_perts(self):\n #emean = self.ensemble_mean()\n return self - self.ensemble_mean()\n #return self.state.values","def get_average_mark(self, test):\n return","def run(self, data):\n for idx, block in enumerate(data):\n current = float(np.mean(block['current']['value']))\n print(f'{idx}: {current}')","def mean_calc(data, col):\n\tm = sum([row[col] for row in data]) / len(data)\n\treturn m","def average(self):\n return np.mean(self.buf[:self._size], axis=0)","def compute_averaged_values(filenames, cols, skip=0, stop=-1, column_major=False, separator='[\\t ]'):\n\n # Read columns\n all_cols = read_file_lines(filenames, cols, skip, stop, column_major, separator)\n\n # Initialise results array\n res = [np.zeros(len(i)) for i in all_cols[0]]\n\n # For each set of columns\n for file_data in all_cols:\n # For each column of the file\n for num, col in enumerate(file_data):\n # Add the value divided by the amount of files considered (to get the average)\n res[num] += col/len(all_cols)\n\n return res","def average_population_grade(population):\r\n total = 0\r\n for individual in population :\r\n total += get_individual_fitness(individual)\r\n return total/POPULATION_COUNT","def calculate_mean(data_dir):\n data = ([each for each in os.listdir(data_dir)\n if each.endswith('.h5')])\n all_data = []\n for num_data in data:\n processed_data = os.path.join(data_dir, num_data)\n file = h5py.File(processed_data, 'r') \n data = file.get('Processed_data') \n all_data.append(data)\n all_data = np.array(all_data)\n all_data = np.mean(all_data, axis=0)\n return all_data","def test_liemdframe_get_average(self):\n\n ave = self.mdframe.get_average()\n\n # Unbound energies should be same value for all poses\n self.assertEqual(len(ave['coul_unbound'].unique()), 1)\n self.assertEqual(len(ave['coul_unbound']), 5)\n self.assertEqual(len(ave['vdw_unbound'].unique()), 1)\n self.assertEqual(len(ave['vdw_unbound']), 5)\n\n # Bound energies mostly unique for all poses\n self.assertEqual(len(ave['coul'].unique()), 5)\n self.assertEqual(len(ave['vdw'].unique()), 5)\n self.assertEqual(len(ave['coul']), 5)\n self.assertEqual(len(ave['vdw']), 5)\n\n # Check values\n self.assertListEqual(list(ave.poses), [1, 2, 3, 4, 5])\n self.assertListEqual(list(ave.cases), [1])\n self.assertAlmostEqual(ave['coul'][0], 60.12452, places=5)\n self.assertAlmostEqual(ave['vdw'][1], -53.78007, places=5)","def compute_GS(GMtcs):\n\n GS = np.mean(GMtcs,axis=0) #average over voxels\n\n return GS","def get_rolling_mean_provenance(self, suptitle, ancestor_files):\n suptitle = suptitle.replace('\\n', '')\n caption = (f\"{suptitle}. For CMIP5 (\"\n f\"{self.formatter(f'cmip5-{self.scenarios[0]}')}, \"\n f\"{self.formatter(f'cmip5-{self.scenarios[1]}')} and \"\n f\"{self.formatter(f'cmip5-{self.scenarios[2]}')}) \"\n f\"and CMIP6 \"\n f\"({self.formatter(f'cmip6-{self.scenarios[0]}')}, \"\n f\"{self.formatter(f'cmip6-{self.scenarios[1]}')} and \"\n f\"{self.formatter(f'cmip6-{self.scenarios[2]}')})\")\n\n record = {\n 'caption': caption,\n 'statistics': ['anomaly', \"other\"],\n 'domains': ['reg', 'global'],\n 'plot_types': ['scatter', 'line', 'times'],\n 'authors': [\n 'cos_josep',\n ],\n 'references': [\n 'cos22esd',\n ],\n 'ancestors': ancestor_files,\n }\n return record","def average_emission(data: List[EmissionPerCapita], current_year: int) -> float:\r\n\r\n index = current_year - data[0].start_year # get the index for current year\r\n\r\n # Get all emissions from that year.\r\n current_year_emissions = []\r\n for countries in data:\r\n current_year_emissions.append(countries.epc_year[index])\r\n\r\n average = sum(current_year_emissions) / len(data)\r\n return average","def mean_height(data):","def mean_height(data):","def average_age():\n df = pd.read_csv(config.META_FQN, sep=\"\\t\")\n ages = []\n for _, row in df.iterrows():\n if row[\"asr_test\"]:\n age = row[\"Age_ses1\"]\n if not math.isnan(age):\n ages.append(age)\n\n print(\"------ Age ------\")\n print_stats(ages)","def mean(self):\n return self._summarize(lambda c: c.mean)","def average(self, returns):\r\n return returns.mean() * self.day","def _compute_mean(self, C, mag, rjb, rake):\n mean = (C['a1'] +\n self._compute_linear_magnitude_term(C, mag) +\n self._compute_quadratic_magnitude_term(C, mag) +\n self._compute_logarithmic_distance_term(C, mag, rjb) +\n self._compute_faulting_style_term(C, rake))\n\n return mean","def _get_mean(self):\n return (0.485, 0.456, 0.406)","def print_avg():","def test_mean_div(self):\n gfile = grades.writers.GradesFile(self.fname)\n gfile.table.compute_mean()\n gfile.table_format = 'org'\n self.check_output(self.output_str3, gfile, div_on=('Group', 'Test 1'))","def global_mean(self):\n return self.interaction_data.label.mean()","def get_avg_f1(ccs):\n scorers = ccs.scorers\n f1_scores = []\n for scorer in scorers:\n f1_scores.append(scorer.get_f1())\n\n avg_f1 = 100 * np.average(f1_scores)\n\n return avg_f1","def get_average(self, samples=50):\n first = self.layers[0].load_image()\n res = np.zeros(first.shape, dtype=float)\n intervals = len(self.layers)/samples\n for l in self.layers[::int(intervals)]:\n img = l.load_image().astype(float)\n res += img\n l.image = None\n return samples**-1*res","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def _mean(self,gp):\r\n return self.gp_link.transf(gp)","def get_average_torsion (phis) :\n shift = phis[0]\n phis_shifted = get_diffvec(phis,shift)\n avg_shifted = phis_shifted.sum()/len(phis)\n average = avg_shifted + shift\n return average","def get_average_torsion (phis) :\n shift = phis[0]\n phis_shifted = get_diffvec(phis,shift)\n avg_shifted = phis_shifted.sum()/len(phis)\n average = avg_shifted + shift\n return average","def mpg_by_make(self):\n ## create reference dict and aggregated dict\n reference_mpgs = defaultdict(list)\n make_avg_mpgs = defaultdict(str)\n ## loop through the data and add to both dicts\n for auto in self.data:\n ## get the year\n the_make = auto.make\n ## maintain a list of mpgs for each key=make\n reference_mpgs[the_make].append(auto.mpg)\n ## update the cumulative mpg as we read auto objects\n make_avg_mpgs[the_make] = sum(reference_mpgs[the_make]) / len(reference_mpgs[the_make])\n return make_avg_mpgs","def calculate_mean_dark(data_dir):\n\n data = ([each for each in os.listdir(data_dir)\n if each.endswith('.h5')])\n \n all_data = []\n for num_data in data:\n #print(num_data)\n processed_data = os.path.join(data_dir, num_data)\n file = h5py.File(processed_data, 'r') \n data = file.get('Processed_data')\n all_data.append(data)\n #print\n\n all_data = np.array(all_data)\n all_data = np.mean(all_data, axis=0)\n return all_data","def cf_mean(self):\n net_power = self['annual_gross_energy'] \\\n - self['annual_thermal_consumption'] # kW-hr\n # q_pb_des is in MW, convert to kW-hr\n name_plate = self['q_pb_design'] * 8760 * 1000\n\n return net_power / name_plate","def get_averages(self):\t\n\t\t\n\t\taverages = {}\n\t\tfor subject in self.grades.iterkeys():\n\t\t\taverages[subject] = float(sum(self.grades[subject])) / len(self.grades[subject])\n\t\treturn averages","def clr_trans(data):\n if isinstance(data, pd.DataFrame):\n data = data.to_numpy()\n data[data == 0] = 1/len(data[0,:])**2 # replace zeros with small constant\n geometric_mean = mstats.gmean(data,axis=1)\n clr_data = np.log(data / geometric_mean[:,None])\n return clr_data","def calccalmean(self,blk):\n calind=self.getcalind(blk)\n x=self.spec[calind,:]\n return np.nanmean(x,axis=0)","def average(data, event):\n if len(data) == 0:\n return 0\n\n score = 0\n # scores = []\n count = 0\n for i in data:\n count += 1\n if event == 'Swim' or event == 'Run':\n num = time_seconds(i[event])\n #print(\"first if\")\n #Sprint(num)\n else:\n num = int(i[event])\n #print(\"second if\")\n #print(num)\n #scores[count] =\n #print(\"end of loop count\" + str(count))\n score += num\n #print (\"score\" + str(score))\n\n # total = 0\n # for x in range(0,len(scores)):\n # total += scores[x]\n score = float(score)\n\n return score / count","def average(X, ebunch):\n edge_embeds = np.zeros((len(ebunch), len(X[list(X.keys())[0]])))\n i = 0\n for edge in ebunch:\n edge_embeds[i] = (X[str(edge[0])] + X[str(edge[1])]) / 2.0\n i += 1\n return edge_embeds","def get_mean(self):\n raise NotImplementedError(\"This is an abstract method and needs to be implemented in derived classes.\")"],"string":"[\n \"def load_average(self):\\n return _favg(self.load_samples)\",\n \"def get_mean(self):\\n mean = np.array(np.zeros((4,8)))\\n for i,c in enumerate(self.cellLines):\\n for j,l in enumerate(self.ligands):\\n mean[i][j] = self.aucs[c][l]['mean']\\n return mean\",\n \"def mean_ensembler(self):\\n models_name = self._get_models_name(self.data_dir)\\n if type(models_name) != list:\\n models_name = [models_name]\\n\\n get_test_y = self._get_model_val(models_name, self.data_dir, 'test')\\n # Calculate the average\\n average = pd.DataFrame()\\n for add in list(get_test_y.keys()):\\n if average.empty:\\n average[self.TAGS] = get_test_y[add][self.TAGS]\\n else:\\n average[self.TAGS] += get_test_y[add][self.TAGS]\\n\\n average = average/len(list(get_test_y.keys()))\\n average.insert(loc=0, column='id', value=self.test_id.values)\\n doc_name = self.data_dir + '/' + 'submission_average_ensembler.csv'\\n average.to_csv(doc_name, index=False)\\n print('submission file saved at {}'.format(doc_name))\\n return average\",\n \"def _ave(self):\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def _ave(self):\\n\\n return np.asarray(np.mean(self.model_estim.x, axis=0)).flatten()\",\n \"def get_average(self):\\n self.avg = math.floor((self.maths + self.phy + self.che) / 3, )\\n self.assign_grade()\\n return self.avg\\n # End of method get_average\",\n \"def get_mean(self):\\r\\n for i in range(1,len(self.data[0])):\\r\\n self.prom.append(np.mean(self.data[:,i]))\",\n \"def ensemble_mean(self):\\n new_cubelist = []\\n for cube in self.cubelist:\\n new_cubelist.append(self.cube_ensemble_mean(cube))\\n self.cubelist = iris.cube.CubeList(new_cubelist)\\n self.processes.append('ensemble_mean')\\n return self.cubelist\",\n \"def getAvg(self):\\r\\n\\t\\treturn self.data['avg']\",\n \"def average(data):\\n return np.average(data)\",\n \"def get_ave(self, recalc=False):\\n if self.ave is not None and not recalc:\\n return self.ave\\n\\n self.ave = np.mean(self.img.ravel())\\n return self.ave\",\n \"def get_original_means(self):\\n return self.meanDataValues\",\n \"def avg_e_score(self, entity):\\n return float(entity['es']) / float(entity['count'])\",\n \"def ensemble_mean(self):\\n return self.mean(dim='mem')\",\n \"def get_average_repro(self):\\n return np.mean([agent.get_fledge_probability() for agent in self.agents])\",\n \"def ensemble_mean(self):\\n self.cube = self.cube_ensemble_mean(self.cube)\\n self.processes.append('ensemble_mean')\\n return self.cube\",\n \"def get_data_copasi_style_d3ct(self, gene, cell_line='A', plot=False, new_name=None,\\n filename=None, indep_dct=None):\\n if gene not in self.genes:\\n raise ValueError('{} is not in list of genes \\\"{}\\\"'.format(gene, self.genes))\\n df = self.d3ct.query('cell_line == \\\"{}\\\" and Assay == \\\"{}\\\"'.format(cell_line, gene))\\n df = pandas.pivot_table(df, values=0, index=['cell_line', 'replicate'], columns='time')\\n mean = df.mean(axis=0)\\n if new_name is not None:\\n mean = pandas.DataFrame(mean, columns=[new_name])\\n else:\\n mean = pandas.DataFrame(mean, columns=[gene])\\n\\n mean = mean.reset_index()\\n mean['time'] = mean['time']*60\\n mean.loc[0] = [0, 0]\\n\\n if indep_dct is not None:\\n for i in indep_dct:\\n if i[-5:] != '_indep':\\n raise ValueError('Keys in indep_dct shuold have _indep as suffix')\\n\\n mean[i] = indep_dct[i]\\n\\n if filename is not None:\\n mean.to_csv(filename, sep='\\\\t', index=False)\\n\\n if plot:\\n mean.plot(x='time')\\n plt.show()\\n\\n return mean\",\n \"def get_average(data):\\n average = sum(data) / len(data)\\n\\n return average\",\n \"def readAvg(self):\\n self.flushInput()\\n\\n if (self.model == 'TDS'):\\n self.write('ACQuire:NUMAVg?\\\\n')\\n return int(self.readline())\\n #elif (self.model == 'GDS'):\\n # FIXME: I'll implement this later. I need to do some\\n # testing, re: whether GDS returns the actual average\\n # number, or log-base-2 of the average number.\",\n \"def get_mean_dict(self):\\n mean = {}\\n for c in self.cellLines:\\n mean[c] = {}\\n for l in self.ligands:\\n mean[c][l] = self.aucs[c][l]['mean']\\n return mean\",\n \"def average(self):\\n return self.summation() / self.count()\",\n \"def annual_average(new_cube):\\n\\n annual_average_cube = new_cube.aggregated_by('year', iris.analysis.MEAN)\\n\\n return annual_average_cube\",\n \"def get_average(self, s_freq, e_freq):\\n s_ind = self.get_bin(s_freq)\\n e_ind = self.get_bin(e_freq)\\n lst = self.mags[s_ind:e_ind+1]\\n try:\\n avg = sum(lst)/len(lst)\\n except:\\n print(s_ind, e_ind)\\n print('werid stuff')\\n avg = 0\\n return avg\",\n \"def get_average_age(self):\\n return np.mean([agent.age for agent in self.agents])\",\n \"def get_mean(self):\\n return self.serie.mean()\",\n \"def gavg(idata):\\n\\t\\n\\twgt1=np.cos(np.deg2rad(idata.lat))*(idata*0+1)\\n\\tga=(wgt1*idata).sum(dim=['lat','lon'])/wgt1.sum(dim=['lat','lon'])\\n\\n\\treturn ga\",\n \"def Mean(data):\\n return data.mean()\",\n \"def _get_mean(self):\\n return [layer._get_mean() for layer in self.layers]\",\n \"def calcAverage(dat):\\n return sum(dat)/len(dat)\",\n \"def slice_avg(self, file_data, slice_range):\\n row_num = 0\\n feature_data = [0] * 7\\n for row in file_data:\\n feature_data[row_num] = sum(row[slice_range[0]:slice_range[1]]) / (slice_range[1] - slice_range[0])\\n row_num += 1\\n self.feature.append(feature_data)\",\n \"def avg(year):\\r\\n df = ouvrir_fichier()\\r\\n df = df.loc[df[\\\"year\\\"].isin([year])]\\r\\n df = df[(\\r\\n df[\\r\\n \\\"emissions\\\"\\r\\n ] == 'Emissions (thousand metric tons of carbon dioxide)'\\r\\n )]\\r\\n print(df)\\r\\n mean_value = df.mean()['value']\\r\\n resultat = {}\\r\\n resultat[\\\"year\\\"] = year\\r\\n resultat['total'] = float(mean_value)\\r\\n print(mean_value)\\r\\n return resultat\",\n \"def compute_fold_regulation(fc_data_list):\\n # if isinstance(fc_data_list, list):\\n return [{TEST_SAMPLE: fc_elem[TEST_SAMPLE], CONTROL_SAMPLE: fc_elem[CONTROL_SAMPLE],\\n FOLD_REGULATION: fc_elem[FOLD_CHANGE].applymap(lambda x: -1.0/x if x < 1.0 else x)}\\n for fc_elem in fc_data_list]\\n # return fc_data_list.applymap(lambda x: -1.0/x if x < 1.0 else x)\",\n \"def average_grade(self):\\n grade_sum = 0\\n grades_length = 0\\n for c in self.courses_grades:\\n if c[1] != \\\"-\\\":\\n grade_sum += int(c[1])\\n grades_length += 1\\n average = grade_sum / grades_length\\n return average\",\n \"def time_average(new_cube):\\n\\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\\n\\n return time_average_cube\",\n \"def _get_average(self):\\n norm = 1.0\\n for pos, idx in enumerate(self.idx):\\n norm *= (self.high[pos] - self.low[pos])\\n return 1.0/norm\",\n \"def average(self):\\n return self.properties.get('average')\",\n \"def get_mean(self):\\n average = self.df[self.col_name].mean()\\n return average\",\n \"def _agg_by_mean(self):\\n return self._data_grouped_by_manufacturer.agg('mean')[['car_value']]\",\n \"def average_length_of_gene(self):\\n return sum([len(e) for e in self.population]) / len(self.population)\",\n \"def get_foldchange(self, exps_for_fc):\\n exp_id_str = get_id_str(self.req_exps)\\n table_name = '%s_datatable_%s' % (self.app_label, exp_id_str)\\n # Make experiment for fold change unique.\\n exps_for_fc = get_unique(exps_for_fc)\\n if not db_table_exists(table_name):\\n self.create_base_table(table_name)\\n column_names = list(get_columnnames(table_name))\\n # Inititialize lists.\\n dividend = [None] * len(exps_for_fc)\\n divisor = [None] * len(exps_for_fc)\\n fc_col_position = [None] * len(exps_for_fc)\\n # Format all columns with scientific notation that end with underscore and a number.\\n datacol_pattern = re.compile(r'_\\\\d+$')\\n for i, column_name in enumerate(column_names):\\n if datacol_pattern.search(column_name) is not None:\\n for j, pair in enumerate(exps_for_fc):\\n pattern = r'_{}$'.format(str(pair['dividend'].id))\\n if re.search(pattern, column_name):\\n if not dividend[j]: \\n dividend[j] = (column_name, pair['dividend'].id,)\\n # For the jth column there will be j columns inserted before that.\\n fc_col_position[j] = i + j\\n elif (str(pair['divisor'].id) in column_name and \\n not divisor[j]):\\n divisor[j] = (column_name, pair['divisor'].id)\\n \\n # Insert the columns for calculating the fold change.\\n for i in range(len(dividend)): \\n fc_col = '{quotient} AS {quotient_name}'.format(\\n quotient=self.wrap_in_func(self.DB_FUNCTION_ZERO, dividend[i][0], divisor[i][0]),\\n quotient_name='\\\"fc_%s/%s\\\"' % (dividend[i][1], divisor[i][1]),\\n )\\n column_names.insert(fc_col_position[i], fc_col)\\n \\n sql = \\\"SELECT %s FROM %s\\\" % (fc_col, table_name)\\n return from_db(sql, fetch_as='tuple')\",\n \"def _compute_cluster_averages(self, key=\\\"_scvi_labels\\\"):\\n # find cell label column\\n label_col = self.adata.uns[\\\"_scvi\\\"][\\\"categorical_mappings\\\"][key][\\\"original_key\\\"]\\n\\n # find data slot\\n x_dict = self.adata.uns[\\\"_scvi\\\"][\\\"data_registry\\\"][\\\"X\\\"]\\n if x_dict[\\\"attr_name\\\"] == \\\"X\\\":\\n use_raw = False\\n else:\\n use_raw = True\\n if x_dict[\\\"attr_name\\\"] == \\\"layers\\\":\\n layer = x_dict[\\\"attr_key\\\"]\\n else:\\n layer = None\\n\\n # compute mean expression of each gene in each cluster/batch\\n aver = compute_cluster_averages(self.adata, labels=label_col, use_raw=use_raw, layer=layer)\\n\\n return aver\",\n \"def average_level(self):\\n spl = [utils.dbspl(x) for x in self.load_files()]\\n return np.mean(spl), np.std(spl)\",\n \"def getMeanE(self):\\n\\n\\n\\t\\tEBefore, EAfter = self.getEnergyEvolution()\\n\\n\\t\\tmeanBefore = np.mean(EBefore[-self.__Nkicks//5:])\\n\\t\\tmeanAfter = np.mean(EAfter[-self.__Nkicks//5:])\\n\\t\\tmeanTot = (meanBefore+meanAfter)/2\\n\\n\\t\\treturn meanBefore, meanAfter, meanTot\",\n \"def average_matrix(self, groups=[\\\"SP\\\", \\\"SL06\\\", \\\"SL12\\\", \\\"SL24\\\",\\\"SL48\\\", \\\"SL96\\\",\\\"FP06\\\", \\\"FP12\\\", \\\"FP24\\\",\\\"FP48\\\", \\\"FP96\\\", \\\"FL\\\"]):\\n\\n # will only work if genes are columns in matrix\\n revert = False\\n if self._genes_as_rows:\\n self.invert_matrix()\\n revert = True\\n\\n limits = self.reorder_matrix(groups=groups)\\n\\n v = numpy.ones((len(groups),self.genenumber)) # create new array of size (y groups) and (n genes)\\n\\n for g in range(self.genenumber):\\n v[0,g] = numpy.average(self.data_matrix[:limits[0],g])\\n for i in range(len(groups)-1):\\n v[i + 1,g] = numpy.average(self.data_matrix[limits[i]:limits[i + 1],g])\\n\\n self.row_header = groups\\n self.column_header = self.gene_header\\n self.data_matrix = v\\n self.refresh_headers()\\n\\n # if matrix was inverted for gene removal, restore to its previous orientation:\\n if revert:\\n self.invert_matrix()\\n self.averaged = True\",\n \"def calc_average_load (self):\\n #~ self.generation = self.forecast.generation_by_type['generation diesel']\\\\\\n #~ [self.start_year]\\n self.average_load = \\\\\\n self.forecast.yearly_average_diesel_load.ix[self.start_year]\",\n \"def _average_data(self):\\n # TODO: This function looks inefficient - can it be improved?\\n output = np.zeros([self.nints_file, self.ngroups_file,\\n self.rows, self.columns], dtype=self.data.dtype)\\n count = np.zeros([self.nints_file, self.ngroups_file, 1, 1],\\n dtype=self.data.dtype)\\n\\n for intg in range(0, self.nints):\\n intg_file = intg // self.intavg\\n for grp in range(0, self.ngroups):\\n grp_file = grp // self.grpavg\\n output[intg_file, grp_file, :, :] += self.data[intg, grp, :, :]\\n count[intg_file, grp_file, 0, 0] += 1.0\\n\\n # Avoid divide by zero.\\n iszero = np.where(count < 1.0)\\n if iszero:\\n count[iszero] = 1.0\\n output = output / count\\n\\n del count \\n return output\",\n \"def store_overall_means(src_file: H5File) -> None:\\n perp_sum = 0\\n par_sum = 0\\n ref_sum = 0\\n counts = 0\\n for path in rawnav.pump_group_paths(src_file):\\n perp_path = path + '/perp'\\n par_path = path + '/par'\\n ref_path = path + '/ref'\\n perp_sum += src_file[perp_path].attrs['mean']\\n par_sum += src_file[par_path].attrs['mean']\\n ref_sum += src_file[ref_path].attrs['mean']\\n counts += 1\\n src_file.attrs['perp_mean'] = perp_sum / counts\\n src_file.attrs['par_mean'] = par_sum / counts\\n src_file.attrs['ref_mean'] = ref_sum / counts\\n return\",\n \"def avg_added(self):\\n avg = {}\\n for path, lines in self.lines_added.items():\\n avg[path] = round(statistics.mean(lines))\\n\\n return avg\",\n \"def calculateAverage(self): \\n if not self.lastTransferAverage: \\n size=[0,0,0,0]\\n for i in range(0,4):\\n if self.lastTransferredChannel & (1 << i):\\n size[i]=self.lastNbrSamplesPerSeg\\n self.lastAverageArray = [zeros(size[0]),zeros(size[1]),zeros(size[2]),zeros(size[3])]\\n nbrSamp=self.lastNbrSamplesPerSeg\\n for i in range(0,4):\\n if self.lastTransferredChannel & (1 << i):\\n nbrSeg=self.lastNbrSegmentsArray[i]\\n for j in range (0,nbrSamp):\\n for k in range(0,nbrSeg): \\n self.lastAverageArray[i][j]+=self.lastWaveformArray[i][k*nbrSamp+j]\\n self.lastAverageArray[i][j]/=nbrSeg\\n self.lastAverageCalculated=True\\n else: print \\\"NOn averaged data are not available\\\"\",\n \"def _image_average(self, images):\\n image_data = [\\n image.normalize().data for image in images\\n # Workaround: skip partial volcano images at the edges\\n if image.data.shape[0] == image.data.shape[1]\\n ]\\n return np.rint(\\n np.mean(image_data, axis=0)\\n ).astype(np.uint8)\",\n \"def get_mean_accuracy(self):\\n return self.df.correct.mean()\",\n \"def gacha_mean(sourcefile, targetfile):\\n sys.stderr.write(err_msg('Calculating Gacha mean, please wait ...\\\\n'))\\n c = num_char(sourcefile) / num_char(targetfile)\\n sys.stderr.write(err_msg('Gacha mean = ' + str(c) + '\\\\n'))\\n sys.stderr.write(err_msg('Filtering starts ...\\\\n'))\\n return c\",\n \"def per_gene_coverage(genes,df):\\n\\n sub_genes =[]\\n\\n #For every gene in the list, check the average coverage, if less than 100 add it to the final list.\\n for gene in genes:\\n coverage = average(df[df['GeneSymbol;Accession'] == gene]['percentage30'])\\n\\n if coverage < 100:\\n sub_genes.append([gene.split(';')[0],round(coverage,2)])\\n \\n return sub_genes\",\n \"def calc_average_load (self):\\n if self.comp_specs['proposed capacity'] != UNKNOWN:\\n self.average_load = None\\n self.generation = self.forecast.generation['generation diesel']\\\\\\n [self.start_year]\\n self.average_load = \\\\\\n self.forecast.yearly_average_diesel_load.ix[self.start_year]\\n #~ print 'self.average_load',self.average_load\",\n \"def get_average_MAE(true_pred_df): \\n age_group = true_pred_df.groupby('y_true')\\n \\n mae_average = []\\n for age, age_data in age_group:\\n mae_average.append(np.mean(age_data.mae))\\n \\n return mae_average\",\n \"def average_strain_data(features, metadata, groups_column='gene_name'):\\n\\n meta_cols = metadata.columns.to_list() \\n data = pd.concat([metadata[groups_column], features], axis=1)\\n mean_data = data.groupby(groups_column).mean()\\n df = metadata.merge(mean_data, how='right', on=groups_column)\\n df = df.groupby(groups_column).first().reset_index()\\n \\n feat = df[[c for c in df.columns if c not in meta_cols]]\\n meta = df[meta_cols]\\n \\n return feat, meta\",\n \"def _get_mean(self):\\n return self._get_conditional_negative_energy()\",\n \"def get_stats(self, gene, groups=[\\\"SP\\\", \\\"SL06\\\", \\\"SL12\\\", \\\"SL24\\\",\\\"SL48\\\", \\\"SL96\\\",\\\"FP06\\\", \\\"FP12\\\", \\\"FP24\\\",\\\"FP48\\\", \\\"FP96\\\", \\\"FL\\\"]):\\n\\n try:\\n pos = self.gene_header.index(gene)\\n except:\\n return [],[]\\n\\n limits = [0] + self.reorder_matrix(groups=groups)\\n #print limits\\n intervals = zip(limits[:-1],limits[1:])\\n print \\\"Debugging: ave and stdev:-\\\"\\n #print intervals\\n #print self.data_matrix\\n #print self.data_matrix[:,pos]\\n #print [ (self.data_matrix[ i:j,pos ]) for i,j in intervals]\\n ave = [ numpy.average(self.data_matrix[ i:j,pos ]) for i,j in intervals]\\n print ave\\n stdev = [ numpy.std(self.data_matrix[ i:j,pos ]) for i,j in intervals]\\n print stdev\\n return ave, stdev\",\n \"def average(data):\\r\\n sum =0\\r\\n for i in data:\\r\\n sum+=i\\r\\n return sum/len(data)\",\n \"def averaged_risk(self):\\n return self._averaged_risk\",\n \"def averaged_risk(self):\\n return self._averaged_risk\",\n \"def ensemble_perts(self):\\n #emean = self.ensemble_mean()\\n return self - self.ensemble_mean()\\n #return self.state.values\",\n \"def get_average_mark(self, test):\\n return\",\n \"def run(self, data):\\n for idx, block in enumerate(data):\\n current = float(np.mean(block['current']['value']))\\n print(f'{idx}: {current}')\",\n \"def mean_calc(data, col):\\n\\tm = sum([row[col] for row in data]) / len(data)\\n\\treturn m\",\n \"def average(self):\\n return np.mean(self.buf[:self._size], axis=0)\",\n \"def compute_averaged_values(filenames, cols, skip=0, stop=-1, column_major=False, separator='[\\\\t ]'):\\n\\n # Read columns\\n all_cols = read_file_lines(filenames, cols, skip, stop, column_major, separator)\\n\\n # Initialise results array\\n res = [np.zeros(len(i)) for i in all_cols[0]]\\n\\n # For each set of columns\\n for file_data in all_cols:\\n # For each column of the file\\n for num, col in enumerate(file_data):\\n # Add the value divided by the amount of files considered (to get the average)\\n res[num] += col/len(all_cols)\\n\\n return res\",\n \"def average_population_grade(population):\\r\\n total = 0\\r\\n for individual in population :\\r\\n total += get_individual_fitness(individual)\\r\\n return total/POPULATION_COUNT\",\n \"def calculate_mean(data_dir):\\n data = ([each for each in os.listdir(data_dir)\\n if each.endswith('.h5')])\\n all_data = []\\n for num_data in data:\\n processed_data = os.path.join(data_dir, num_data)\\n file = h5py.File(processed_data, 'r') \\n data = file.get('Processed_data') \\n all_data.append(data)\\n all_data = np.array(all_data)\\n all_data = np.mean(all_data, axis=0)\\n return all_data\",\n \"def test_liemdframe_get_average(self):\\n\\n ave = self.mdframe.get_average()\\n\\n # Unbound energies should be same value for all poses\\n self.assertEqual(len(ave['coul_unbound'].unique()), 1)\\n self.assertEqual(len(ave['coul_unbound']), 5)\\n self.assertEqual(len(ave['vdw_unbound'].unique()), 1)\\n self.assertEqual(len(ave['vdw_unbound']), 5)\\n\\n # Bound energies mostly unique for all poses\\n self.assertEqual(len(ave['coul'].unique()), 5)\\n self.assertEqual(len(ave['vdw'].unique()), 5)\\n self.assertEqual(len(ave['coul']), 5)\\n self.assertEqual(len(ave['vdw']), 5)\\n\\n # Check values\\n self.assertListEqual(list(ave.poses), [1, 2, 3, 4, 5])\\n self.assertListEqual(list(ave.cases), [1])\\n self.assertAlmostEqual(ave['coul'][0], 60.12452, places=5)\\n self.assertAlmostEqual(ave['vdw'][1], -53.78007, places=5)\",\n \"def compute_GS(GMtcs):\\n\\n GS = np.mean(GMtcs,axis=0) #average over voxels\\n\\n return GS\",\n \"def get_rolling_mean_provenance(self, suptitle, ancestor_files):\\n suptitle = suptitle.replace('\\\\n', '')\\n caption = (f\\\"{suptitle}. For CMIP5 (\\\"\\n f\\\"{self.formatter(f'cmip5-{self.scenarios[0]}')}, \\\"\\n f\\\"{self.formatter(f'cmip5-{self.scenarios[1]}')} and \\\"\\n f\\\"{self.formatter(f'cmip5-{self.scenarios[2]}')}) \\\"\\n f\\\"and CMIP6 \\\"\\n f\\\"({self.formatter(f'cmip6-{self.scenarios[0]}')}, \\\"\\n f\\\"{self.formatter(f'cmip6-{self.scenarios[1]}')} and \\\"\\n f\\\"{self.formatter(f'cmip6-{self.scenarios[2]}')})\\\")\\n\\n record = {\\n 'caption': caption,\\n 'statistics': ['anomaly', \\\"other\\\"],\\n 'domains': ['reg', 'global'],\\n 'plot_types': ['scatter', 'line', 'times'],\\n 'authors': [\\n 'cos_josep',\\n ],\\n 'references': [\\n 'cos22esd',\\n ],\\n 'ancestors': ancestor_files,\\n }\\n return record\",\n \"def average_emission(data: List[EmissionPerCapita], current_year: int) -> float:\\r\\n\\r\\n index = current_year - data[0].start_year # get the index for current year\\r\\n\\r\\n # Get all emissions from that year.\\r\\n current_year_emissions = []\\r\\n for countries in data:\\r\\n current_year_emissions.append(countries.epc_year[index])\\r\\n\\r\\n average = sum(current_year_emissions) / len(data)\\r\\n return average\",\n \"def mean_height(data):\",\n \"def mean_height(data):\",\n \"def average_age():\\n df = pd.read_csv(config.META_FQN, sep=\\\"\\\\t\\\")\\n ages = []\\n for _, row in df.iterrows():\\n if row[\\\"asr_test\\\"]:\\n age = row[\\\"Age_ses1\\\"]\\n if not math.isnan(age):\\n ages.append(age)\\n\\n print(\\\"------ Age ------\\\")\\n print_stats(ages)\",\n \"def mean(self):\\n return self._summarize(lambda c: c.mean)\",\n \"def average(self, returns):\\r\\n return returns.mean() * self.day\",\n \"def _compute_mean(self, C, mag, rjb, rake):\\n mean = (C['a1'] +\\n self._compute_linear_magnitude_term(C, mag) +\\n self._compute_quadratic_magnitude_term(C, mag) +\\n self._compute_logarithmic_distance_term(C, mag, rjb) +\\n self._compute_faulting_style_term(C, rake))\\n\\n return mean\",\n \"def _get_mean(self):\\n return (0.485, 0.456, 0.406)\",\n \"def print_avg():\",\n \"def test_mean_div(self):\\n gfile = grades.writers.GradesFile(self.fname)\\n gfile.table.compute_mean()\\n gfile.table_format = 'org'\\n self.check_output(self.output_str3, gfile, div_on=('Group', 'Test 1'))\",\n \"def global_mean(self):\\n return self.interaction_data.label.mean()\",\n \"def get_avg_f1(ccs):\\n scorers = ccs.scorers\\n f1_scores = []\\n for scorer in scorers:\\n f1_scores.append(scorer.get_f1())\\n\\n avg_f1 = 100 * np.average(f1_scores)\\n\\n return avg_f1\",\n \"def get_average(self, samples=50):\\n first = self.layers[0].load_image()\\n res = np.zeros(first.shape, dtype=float)\\n intervals = len(self.layers)/samples\\n for l in self.layers[::int(intervals)]:\\n img = l.load_image().astype(float)\\n res += img\\n l.image = None\\n return samples**-1*res\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def _mean(self,gp):\\r\\n return self.gp_link.transf(gp)\",\n \"def get_average_torsion (phis) :\\n shift = phis[0]\\n phis_shifted = get_diffvec(phis,shift)\\n avg_shifted = phis_shifted.sum()/len(phis)\\n average = avg_shifted + shift\\n return average\",\n \"def get_average_torsion (phis) :\\n shift = phis[0]\\n phis_shifted = get_diffvec(phis,shift)\\n avg_shifted = phis_shifted.sum()/len(phis)\\n average = avg_shifted + shift\\n return average\",\n \"def mpg_by_make(self):\\n ## create reference dict and aggregated dict\\n reference_mpgs = defaultdict(list)\\n make_avg_mpgs = defaultdict(str)\\n ## loop through the data and add to both dicts\\n for auto in self.data:\\n ## get the year\\n the_make = auto.make\\n ## maintain a list of mpgs for each key=make\\n reference_mpgs[the_make].append(auto.mpg)\\n ## update the cumulative mpg as we read auto objects\\n make_avg_mpgs[the_make] = sum(reference_mpgs[the_make]) / len(reference_mpgs[the_make])\\n return make_avg_mpgs\",\n \"def calculate_mean_dark(data_dir):\\n\\n data = ([each for each in os.listdir(data_dir)\\n if each.endswith('.h5')])\\n \\n all_data = []\\n for num_data in data:\\n #print(num_data)\\n processed_data = os.path.join(data_dir, num_data)\\n file = h5py.File(processed_data, 'r') \\n data = file.get('Processed_data')\\n all_data.append(data)\\n #print\\n\\n all_data = np.array(all_data)\\n all_data = np.mean(all_data, axis=0)\\n return all_data\",\n \"def cf_mean(self):\\n net_power = self['annual_gross_energy'] \\\\\\n - self['annual_thermal_consumption'] # kW-hr\\n # q_pb_des is in MW, convert to kW-hr\\n name_plate = self['q_pb_design'] * 8760 * 1000\\n\\n return net_power / name_plate\",\n \"def get_averages(self):\\t\\n\\t\\t\\n\\t\\taverages = {}\\n\\t\\tfor subject in self.grades.iterkeys():\\n\\t\\t\\taverages[subject] = float(sum(self.grades[subject])) / len(self.grades[subject])\\n\\t\\treturn averages\",\n \"def clr_trans(data):\\n if isinstance(data, pd.DataFrame):\\n data = data.to_numpy()\\n data[data == 0] = 1/len(data[0,:])**2 # replace zeros with small constant\\n geometric_mean = mstats.gmean(data,axis=1)\\n clr_data = np.log(data / geometric_mean[:,None])\\n return clr_data\",\n \"def calccalmean(self,blk):\\n calind=self.getcalind(blk)\\n x=self.spec[calind,:]\\n return np.nanmean(x,axis=0)\",\n \"def average(data, event):\\n if len(data) == 0:\\n return 0\\n\\n score = 0\\n # scores = []\\n count = 0\\n for i in data:\\n count += 1\\n if event == 'Swim' or event == 'Run':\\n num = time_seconds(i[event])\\n #print(\\\"first if\\\")\\n #Sprint(num)\\n else:\\n num = int(i[event])\\n #print(\\\"second if\\\")\\n #print(num)\\n #scores[count] =\\n #print(\\\"end of loop count\\\" + str(count))\\n score += num\\n #print (\\\"score\\\" + str(score))\\n\\n # total = 0\\n # for x in range(0,len(scores)):\\n # total += scores[x]\\n score = float(score)\\n\\n return score / count\",\n \"def average(X, ebunch):\\n edge_embeds = np.zeros((len(ebunch), len(X[list(X.keys())[0]])))\\n i = 0\\n for edge in ebunch:\\n edge_embeds[i] = (X[str(edge[0])] + X[str(edge[1])]) / 2.0\\n i += 1\\n return edge_embeds\",\n \"def get_mean(self):\\n raise NotImplementedError(\\\"This is an abstract method and needs to be implemented in derived classes.\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5692266","0.5642145","0.5442966","0.5387502","0.53431314","0.5342711","0.5338354","0.53111","0.5289658","0.5284847","0.52795583","0.5262822","0.5248242","0.52306324","0.5225943","0.52127075","0.52108794","0.519317","0.51858854","0.5179068","0.51451385","0.51356834","0.5134186","0.5132019","0.5123962","0.5073243","0.50683963","0.50586534","0.5057024","0.5047836","0.50405586","0.50359154","0.5033599","0.50298053","0.502788","0.5026219","0.5019853","0.50131065","0.500591","0.50003016","0.49965152","0.49929953","0.49923044","0.4983934","0.4981318","0.4973075","0.49712494","0.49685064","0.49667627","0.49594715","0.495025","0.4942099","0.49196956","0.49163136","0.4914257","0.49133804","0.4903778","0.48985398","0.4897546","0.48777446","0.48777446","0.4876241","0.48718718","0.48687136","0.48622194","0.48606917","0.48504817","0.48499447","0.48472932","0.48468047","0.48438963","0.48387963","0.48370132","0.48315385","0.48315385","0.48167613","0.48113802","0.4806704","0.47944412","0.4793422","0.47902608","0.47869182","0.47827232","0.47772667","0.47748482","0.47748166","0.47748166","0.47748166","0.47748166","0.47748166","0.47713423","0.47713423","0.47695056","0.4768351","0.4766963","0.4765133","0.4763143","0.47610137","0.4760928","0.47578213","0.4754136"],"string":"[\n \"0.5692266\",\n \"0.5642145\",\n \"0.5442966\",\n \"0.5387502\",\n \"0.53431314\",\n \"0.5342711\",\n \"0.5338354\",\n \"0.53111\",\n \"0.5289658\",\n \"0.5284847\",\n \"0.52795583\",\n \"0.5262822\",\n \"0.5248242\",\n \"0.52306324\",\n \"0.5225943\",\n \"0.52127075\",\n \"0.52108794\",\n \"0.519317\",\n \"0.51858854\",\n \"0.5179068\",\n \"0.51451385\",\n \"0.51356834\",\n \"0.5134186\",\n \"0.5132019\",\n \"0.5123962\",\n \"0.5073243\",\n \"0.50683963\",\n \"0.50586534\",\n \"0.5057024\",\n \"0.5047836\",\n \"0.50405586\",\n \"0.50359154\",\n \"0.5033599\",\n \"0.50298053\",\n \"0.502788\",\n \"0.5026219\",\n \"0.5019853\",\n \"0.50131065\",\n \"0.500591\",\n \"0.50003016\",\n \"0.49965152\",\n \"0.49929953\",\n \"0.49923044\",\n \"0.4983934\",\n \"0.4981318\",\n \"0.4973075\",\n \"0.49712494\",\n \"0.49685064\",\n \"0.49667627\",\n \"0.49594715\",\n \"0.495025\",\n \"0.4942099\",\n \"0.49196956\",\n \"0.49163136\",\n \"0.4914257\",\n \"0.49133804\",\n \"0.4903778\",\n \"0.48985398\",\n \"0.4897546\",\n \"0.48777446\",\n \"0.48777446\",\n \"0.4876241\",\n \"0.48718718\",\n \"0.48687136\",\n \"0.48622194\",\n \"0.48606917\",\n \"0.48504817\",\n \"0.48499447\",\n \"0.48472932\",\n \"0.48468047\",\n \"0.48438963\",\n \"0.48387963\",\n \"0.48370132\",\n \"0.48315385\",\n \"0.48315385\",\n \"0.48167613\",\n \"0.48113802\",\n \"0.4806704\",\n \"0.47944412\",\n \"0.4793422\",\n \"0.47902608\",\n \"0.47869182\",\n \"0.47827232\",\n \"0.47772667\",\n \"0.47748482\",\n \"0.47748166\",\n \"0.47748166\",\n \"0.47748166\",\n \"0.47748166\",\n \"0.47748166\",\n \"0.47713423\",\n \"0.47713423\",\n \"0.47695056\",\n \"0.4768351\",\n \"0.4766963\",\n \"0.4765133\",\n \"0.4763143\",\n \"0.47610137\",\n \"0.4760928\",\n \"0.47578213\",\n \"0.4754136\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12882,"cells":{"query":{"kind":"string","value":"Split design by subexperiment (1, 2, 3) and create SubExperiment objects"},"document":{"kind":"string","value":"def create_subexperiments(self):\n subexperiments = {}\n for label, df in self.design.groupby(level=0):\n subexperiments[label] = SubExperiment(label, df.loc[label], self.root)\n return subexperiments"},"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 test_expand_experiments():\n template_script = get_template_script()\n experiment_systems = utils.CombinatorialLeaf(['explicit-system', 'implicit-system', 'hydration-system'])\n template_script['experiments']['system'] = experiment_systems\n\n exp_builder = ExperimentBuilder(script=template_script, job_id=1, n_jobs=2)\n experiments = list(exp_builder._expand_experiments())\n assert len(experiments) == 2\n\n exp_builder = ExperimentBuilder(script=template_script, job_id=2, n_jobs=2)\n experiments = list(exp_builder._expand_experiments())\n assert len(experiments) == 1","def set_sub_models(self):\r\n sub_data_grid = [0.1 * i for i in range(1, 10)]\r\n self.sub_models = [\r\n copy.deepcopy(self.model_) for _ in range(len(sub_data_grid))]\r\n # fit sub-models to subset of data\r\n for key, data_size in enumerate(sub_data_grid):\r\n X, _, y, _ = train_test_split(\r\n self.X_train, self.y_train.ravel(),\r\n train_size=data_size,\r\n random_state=self.seeds.get('l_curve_seed', 22))\r\n self.sub_models[key].fit(X, y)","def get_subensemble_parts(self, num_parts):\n parts = []\n\n decoder_parts = self.get_subensemble_decoder(num_parts, \"X\")\n\n encoder_length = len(self.encoders)\n bias_length = len(self.bias)\n\n # create the specified number of subensembles\n for e_num in range(1, num_parts + 1):\n e_size = encoder_length / num_parts\n b_size = bias_length / num_parts\n\n encoder_part = self.encoders[e_size * (e_num - 1):e_size * e_num]\n bias_part = self.bias[b_size * (e_num - 1):b_size * e_num]\n\n parts.append((encoder_part, decoder_parts[e_num - 1], bias_part))\n\n return parts","def splits(cls, exts, fields, root='/Users/yingliu/PycharmProjects/Seq2SeqSemantic/data/',\n train='train2', validation='val2', test='test2', **kwargs):\n return super(SPDataset, cls).splits(\n exts, fields, path=root,\n train = train, validation = validation, test = test, **kwargs)","def _build_experiment_embedded_list():\n pass","def split_test_data():\n outputvis = ROOT_DIR + 'test_imaging/test_split_1eb.ms'\n targ = TARGETS['NGC1333IRAS4A']\n spw = '{0}:236~276'.format(SPWS[targ.name]['NH3_11'].spw_id)\n split(\n vis=get_vis_name(targ),\n outputvis=outputvis,\n field=targ.name,\n spw=spw,\n )","def create_sub_mdps(self, level):\n\n mdps_copy = set(self.mdps[level-1].copy())\n mdps = set()\n upper_level_exits = {}\n\n # Full depth-first search to group MDPs into MERs\n while len(mdps_copy) > 0:\n curr_mdp = random.choice(tuple(mdps_copy))\n mer, exits = set(), set()\n # Group curr_mdp with neighbors to form a MER and find exits\n self.dfs(mdps_copy, curr_mdp, level, mer, exits)\n # Choose a state var that is representative of the new MER\n state_var = next(iter(mer)).state_var[1:]\n # Create a new upper level MDP and set its properties\n mdp = MDP(level=level, state_var=state_var)\n mdp.mer = frozenset(mer)\n\n upper_level_exits[mdp] = exits\n for _mdp in mer:\n mdp.primitive_states.update(_mdp.primitive_states)\n mdps.add(mdp)\n\n self.mdps[level] = mdps\n\n # Add MDP Exits/Actions\n for mdp in self.mdps[level]:\n mdp.exits = set()\n # Generate new exits (mdp at level, Exit at level-1, target mdp at level)\n for s_mdp, exit, n_mdp in upper_level_exits[mdp]:\n neighbor_mdp = n_mdp.get_upper_mdp(self.mdps) \n mdp.exits.add(Exit(mdp, Exit(s_mdp, exit, n_mdp), neighbor_mdp))","def setup_experiment(testruns, droplist=\"\"):\n ex = Experiment()\n ex.addSoluFile(ALL_SOLU)\n\n regexlist = []\n for x in droplist.split(\",\"):\n # defaultvalue, if empty we don't want to exclude everything\n if x == \"\":\n continue\n try:\n y = re.compile(x)\n regexlist.append(y)\n except:\n pass\n\n excluded_inst = []\n # get data\n for t in testruns:\n # update representation\n additional_data = {\"RubberbandId\": get_rbid_representation(t, \"extended\")}\n\n # collect data and pass to ipet\n ipettestrun = TestRun()\n tr_raw_data = t.get_data(add_data=additional_data)\n\n tr_data = {}\n for i in tr_raw_data.keys():\n for r in regexlist:\n if r.match(i):\n excluded_inst.append(i)\n break\n else:\n tr_data[i] = tr_raw_data[i]\n\n ipettestrun.data = pd.DataFrame(tr_data).T\n\n ex.testruns.append(ipettestrun)\n return ex, excluded_inst","def split_dataset(dataset, eval_proportion, shuffle=False):\n split_sizes = [1. - eval_proportion, eval_proportion]\n split_frames = []\n split_demos = []\n num_demos = dataset.get_num_demos()\n split_num_demos = [int(fraction * num_demos) for fraction in split_sizes]\n split_num_demos[0] += num_demos - sum(split_num_demos)\n num_instances = len(dataset)\n demos = list(range(num_demos))\n if shuffle:\n np.random.shuffle(demos)\n start_idx = 0\n for split_idx in range(len(split_sizes)):\n if split_sizes[split_idx] == 0:\n split_frames.append(None)\n continue\n split_frames.append([])\n split_demos.append(range(start_idx, start_idx + split_num_demos[split_idx]))\n for demo_idx in split_demos[split_idx]:\n demo_slice = dataset.get_demo_frame_idxs(demos[demo_idx])\n split_frames[split_idx].extend(\n list(range(demo_slice.start, demo_slice.stop)))\n start_idx += split_num_demos[split_idx]\n # Check if the split indices are unique\n assert len(set(split_frames[split_idx])) == len(split_frames[split_idx])\n\n if eval_proportion > 0:\n # Check that splits do not intersect\n for split_idx in range(len(split_frames)):\n for split_idx2 in range(split_idx + 1, len(split_frames)):\n assert len(set(split_frames[split_idx]).intersection(split_frames[split_idx2])) == 0\n assert sum([len(s) for s in split_frames]) == num_instances\n\n split_datasets = [Subset(dataset, split) if split is not None else None for split in split_frames]\n return split_datasets","def subanalyses(self, subject_id, data):\n raise NotImplementedError('not implemented in abstract class')","def build_experiments(self):\n\n # width=500, height=350, pos_x= 2.0, pos_y=0.0, pos_z= 1.4, angle=-30.0\n cameraRGB = Camera('Camera', PostProcessing='SceneFinal')\n cameraRGB.set_image_size(500, 350)\n cameraRGB.set_position(2.0, 0.0, 1.4)\n cameraRGB.set_rotation(-30.0, 0.0, 0.)\n cameraRGB.set(FOV=100)\n\n camera = Camera('CameraSem', PostProcessing='SemanticSegmentation')\n camera.set_image_size(320, 180)\n camera.set_position(2.0, 0.0, 1.4)\n camera.set_rotation(-30.0, 0.0, 0.)\n camera.set(FOV=100)\n\n if self._city_name == 'Town01':\n poses_tasks = self._poses_town01()\n vehicles_tasks = []\n pedestrians_tasks = []\n for i in range(len(poses_tasks)):\n vehicles_tasks.append(0)\n pedestrians_tasks.append(0)\n\n experiment_vector = []\n\n for weather in self.weathers:\n\n for iteration in range(len(poses_tasks)):\n poses = poses_tasks[iteration]\n vehicles = vehicles_tasks[iteration]\n pedestrians = pedestrians_tasks[iteration]\n\n conditions = CarlaSettings()\n conditions.set(\n SendNonPlayerAgentsInfo=True,\n NumberOfVehicles=vehicles,\n NumberOfPedestrians=pedestrians,\n WeatherId=weather,\n QualityLevel=1\n )\n\n conditions.set(SynchronousMode=True)\n conditions.set(DisableTwoWheeledVehicles=True)\n\n conditions.add_sensor(camera)\n conditions.add_sensor(cameraRGB)\n\n experiment = Experiment()\n experiment.set(\n Conditions=conditions,\n Poses=poses,\n Task=iteration,\n Repetitions=1\n )\n\n experiment_vector.append(experiment)\n\n return experiment_vector","def setUp(self):\n self.splits = (2,3,4)","def three_experiments(two_experiments, one_experiment):","def _split(self, split, randomise=False, **kwargs):\r\n # Copy split to prevent modifying outside arguments\r\n split = split.copy()\r\n # Compute total\r\n total = sum(split.values())\r\n # If split contains floats, convert to integers\r\n if isinstance(total, float):\r\n assert_msg = 'Not enough data! ' \\\r\n + f'Split requires a total of {total*100}%. ' \\\r\n + 'Split should not exceed 100%.'\r\n assert total <= 1, assert_msg\r\n # Add 'rest' subset if not all data is used in split\r\n if total < 1:\r\n split['rest'] = 1 - total\r\n split = self._float_split_to_int(split)\r\n total = sum(split.values())\r\n # Create subsets based off integer values\r\n if isinstance(total, int):\r\n assert_msg = 'Not enough data! ' \\\r\n + f'Split requires a total of {total} data entries ' \\\r\n + f'but only {len(self.data)} are available.'\r\n assert total <= len(self.data), assert_msg\r\n # Add 'rest' subset if not all data is used in split\r\n if total < len(self.data):\r\n split['rest'] = len(self.data) - total\r\n # Create subsets\r\n index = 0\r\n for name, length in split.items():\r\n subset_name = f'{self.name}.{name}'\r\n subset_data = self.data[index:index + length]\r\n subset_seed = self.seed\r\n if self.seed is not None:\r\n subset_seed += sum([ord(c) for c in name]) + length\r\n subset = self._make_subset(subset_name,\r\n subset_data,\r\n randomise=randomise,\r\n seed=subset_seed,\r\n **kwargs\r\n )\r\n setattr(self, name, subset)\r\n index += length\r\n # Replace data with references to subsets\r\n self.data = []\r\n for name in split.keys():\r\n self.data.append(getattr(self, name, None))\r\n # Indicate that this is a superset\r\n self.is_superset = True","def make_multiinstantiate(self, special_properties, name, parameters):\n PARAM_SUBSCRIPT = \"_p\"\n self._model_namespace[\"ct_populationname\"] = name+\"Multi\"\n multi_ct = lems.ComponentType(self._model_namespace[\"ct_populationname\"], extends=BASE_POPULATION)\n structure = lems.Structure()\n multi_ins = lems.MultiInstantiate(component_type=name,\n number=\"N\")\n param_dict = {}\n # number of neruons\n multi_ct.add(lems.Parameter(name=\"N\", dimension=\"none\"))\n # other parameters\n for sp in special_properties:\n if special_properties[sp] is None:\n multi_ct.add(lems.Parameter(name=sp+PARAM_SUBSCRIPT, dimension=self._all_params_unit[sp]))\n multi_ins.add(lems.Assign(property=sp, value=sp+PARAM_SUBSCRIPT))\n param_dict[sp] = parameters[sp]\n else:\n # multi_ct.add(lems.Parameter(name=sp, dimension=self._all_params_unit[sp]))\n # check if there are some units in equations\n equation = special_properties[sp]\n # add spaces around brackets to prevent mismatching\n equation = re.sub(\"\\(\", \" ( \", equation)\n equation = re.sub(\"\\)\", \" ) \", equation)\n for i in get_identifiers(equation):\n # iterator is a special case\n if i == \"i\":\n regexp_noletter = \"[^a-zA-Z0-9]\"\n equation = re.sub(\"{re}i{re}\".format(re=regexp_noletter),\n \" {} \".format(INDEX), equation)\n # here it's assumed that we don't use Netwton in neuron models\n elif i in name_to_unit and i != \"N\":\n const_i = i+'const'\n multi_ct.add(lems.Constant(name=const_i, symbol=const_i,\n dimension=self._all_params_unit[sp], value=\"1\"+i))\n equation = re.sub(i, const_i, equation)\n multi_ins.add(lems.Assign(property=sp, value=equation))\n structure.add(multi_ins)\n multi_ct.structure = structure\n self._model.add(multi_ct)\n param_dict = dict([(k+\"_p\", v) for k, v in param_dict.items()])\n param_dict[\"N\"] = self._nr_of_neurons\n self._model_namespace[\"populationname\"] = self._model_namespace[\"ct_populationname\"] + \"pop\"\n self._model_namespace[\"networkname\"] = self._model_namespace[\"ct_populationname\"] + \"Net\"\n self.add_population(self._model_namespace[\"networkname\"],\n self._model_namespace[\"populationname\"],\n self._model_namespace[\"ct_populationname\"],\n **param_dict)","def get_subensemble_decoder(self, num_parts, origin_name, func=None):\n parts = []\n\n # TODO do not require an Origin to be created just to compute decoder\n if origin_name not in self.origin:\n # create the origin in order to compute a decoder\n self.add_origin(origin_name, func)\n # print \"name \" + self.name + \" decoder: \" + str(self.origin[origin_name].decoder)\n\n decoder = self.origin[origin_name].decoder\n decoder_length = len(decoder)\n\n # create the specified number of decoders\n for e_num in range(1, num_parts + 1):\n d_size = decoder_length / num_parts\n decoder_part = decoder[d_size * (e_num - 1):d_size * e_num]\n\n parts.append(decoder_part)\n\n return parts","def generate_submissons_all_steps():\n\n\n data_en = read_json_file(\"Test_Data/test-en.json\")\n data_pr = read_json_file(\"Test_Data/test-pr.json\")\n data_es = read_json_file(\"Test_Data/test-es.json\")\n res_en = generate_embeddings_sentence_test_data(data_en, \"Test_Data/embd-en.pkl\")\n res_es = generate_embeddings_sentence_test_data(data_es, \"Test_Data/embd-es.pkl\")\n res_pr = generate_embeddings_sentence_test_data(data_pr, \"Test_Data/embd-pr.pkl\")\n model = load_model(\"model_doc\")\n make_submission(res_es, model, \"submission-es\")\n make_submission(res_pr, model, \"submission-pr\")\n make_submission(res_en, model, \"submission-en\")\n exit()","def decode(self):\n # Extract all the experiments\n\n # Map of imageset/scan pairs\n imagesets = {}\n\n # For every experiment, use the given input to create\n # a sensible experiment.\n el = ExperimentList()\n for eobj in self._obj[\"experiment\"]:\n\n # Get the models\n identifier = eobj.get(\"identifier\", \"\")\n beam = self._lookup_model(\"beam\", eobj)\n detector = self._lookup_model(\"detector\", eobj)\n goniometer = self._lookup_model(\"goniometer\", eobj)\n scan = self._lookup_model(\"scan\", eobj)\n crystal = self._lookup_model(\"crystal\", eobj)\n profile = self._lookup_model(\"profile\", eobj)\n scaling_model = self._lookup_model(\"scaling_model\", eobj)\n\n key = (eobj.get(\"imageset\"), eobj.get(\"scan\"))\n\n imageset = None\n try:\n imageset = imagesets[key] # type: ImageSet\n except KeyError:\n # This imageset hasn't been loaded yet - create it\n imageset_data = self._lookup_model(\"imageset\", eobj)\n\n # Create the imageset from the input data\n if imageset_data is not None:\n if \"params\" in imageset_data:\n format_kwargs = imageset_data[\"params\"]\n else:\n format_kwargs = {}\n\n # Load the external lookup data\n mask_filename, mask = self._load_pickle_path(imageset_data, \"mask\")\n gain_filename, gain = self._load_pickle_path(imageset_data, \"gain\")\n pedestal_filename, pedestal = self._load_pickle_path(\n imageset_data, \"pedestal\"\n )\n dx_filename, dx = self._load_pickle_path(imageset_data, \"dx\")\n dy_filename, dy = self._load_pickle_path(imageset_data, \"dy\")\n\n if imageset_data[\"__id__\"] == \"ImageSet\":\n imageset = self._make_stills(\n imageset_data, format_kwargs=format_kwargs\n )\n elif imageset_data[\"__id__\"] == \"ImageGrid\":\n imageset = self._make_grid(\n imageset_data, format_kwargs=format_kwargs\n )\n elif (\n imageset_data[\"__id__\"] == \"ImageSequence\"\n or imageset_data[\"__id__\"] == \"ImageSweep\"\n ):\n imageset = self._make_sequence(\n imageset_data,\n beam=beam,\n detector=detector,\n goniometer=goniometer,\n scan=scan,\n format_kwargs=format_kwargs,\n )\n elif imageset_data[\"__id__\"] == \"MemImageSet\":\n imageset = self._make_mem_imageset(imageset_data)\n else:\n raise RuntimeError(\"Unknown imageset type\")\n\n if imageset is not None:\n # Set the external lookup\n if mask is None:\n mask = ImageBool()\n else:\n mask = ImageBool(mask)\n if gain is None:\n gain = ImageDouble()\n else:\n gain = ImageDouble(gain)\n if pedestal is None:\n pedestal = ImageDouble()\n else:\n pedestal = ImageDouble(pedestal)\n if dx is None:\n dx = ImageDouble()\n else:\n dx = ImageDouble(dx)\n if dy is None:\n dy = ImageDouble()\n else:\n dy = ImageDouble(dy)\n\n if not imageset.external_lookup.mask.data.empty():\n if not mask.empty():\n mask = tuple(m.data() for m in mask)\n for m1, m2 in zip(\n mask, imageset.external_lookup.mask.data\n ):\n m1 &= m2.data()\n imageset.external_lookup.mask.data = ImageBool(mask)\n else:\n imageset.external_lookup.mask.data = mask\n imageset.external_lookup.mask.filename = mask_filename\n imageset.external_lookup.gain.data = gain\n imageset.external_lookup.gain.filename = gain_filename\n imageset.external_lookup.pedestal.data = pedestal\n imageset.external_lookup.pedestal.filename = pedestal_filename\n imageset.external_lookup.dx.data = dx\n imageset.external_lookup.dx.filename = dx_filename\n imageset.external_lookup.dy.data = dy\n imageset.external_lookup.dy.filename = dy_filename\n\n # Update the imageset models\n if isinstance(imageset, ImageSequence):\n imageset.set_beam(beam)\n imageset.set_detector(detector)\n imageset.set_goniometer(goniometer)\n imageset.set_scan(scan)\n elif isinstance(imageset, (ImageSet, ImageGrid)):\n for i in range(len(imageset)):\n imageset.set_beam(beam, i)\n imageset.set_detector(detector, i)\n imageset.set_goniometer(goniometer, i)\n imageset.set_scan(scan, i)\n\n imageset.update_detector_px_mm_data()\n\n # Add the imageset to the dict - even if empty - as this will\n # prevent a duplicated attempt at reconstruction\n imagesets[key] = imageset\n\n # Append the experiment\n el.append(\n Experiment(\n imageset=imageset,\n beam=beam,\n detector=detector,\n goniometer=goniometer,\n scan=scan,\n crystal=crystal,\n profile=profile,\n scaling_model=scaling_model,\n identifier=identifier,\n )\n )\n\n # Return the experiment list\n return el","def train_data_split(self, selected_sr, selected_ss):\n \"\"\"\n Arguments:\n selected_sr: ordinal number of the selected split ratio\n selected_ss: ordinal number of split shift\n \"\"\"\n assert selected_sr < len(self.split_ratios),\\\n \"The total number of possible split ratios is: %d\"\\\n % len(self.split_ratios)\n\n max_shifts = 100 / self.split_ratios[selected_sr][-1]\n\n assert selected_ss < max_shifts,\\\n \"The total number of split shifts is: %d\" % max_shifts\n\n self.empty_split()\n\n n = float(self.n_train) / max_shifts\n self.n_develop = int(self.split_ratios[selected_sr][0] /\n (100 / max_shifts) * n)\n\n self.n_valid = int(self.split_ratios[selected_sr][1] /\n (100 / max_shifts) * n)\n\n self.n_eval = self.n_train - self.n_develop - self.n_valid\n\n for i in range(self.n_develop):\n self.development_subjects.\\\n append(self.training_subjects[(selected_ss * self.n_eval + i) %\n self.n_train])\n\n for i in range(self.n_valid):\n self.validation_subjects.\\\n append(self.training_subjects[(selected_ss * self.n_eval +\n self.n_develop + i) %\n self.n_train])\n\n for i in range(self.n_eval):\n self.evaluation_subjects.\\\n append(self.training_subjects[(selected_ss * self.n_eval +\n self.n_develop +\n self.n_valid + i) %\n self.n_train])","def __init__(self, transform, num_subbursts=1, parts_subset=None, \n pct_subset=None, balance=True, random_start_points=False, seed1=4, seed2=33):\n self.dp = DataPipeline(\"\",\"\")\n self.metadata = self.dp.get_metadata()\n if parts_subset:\n self.metadata = self.metadata[self.metadata.part.isin(parts_subset)]\n if pct_subset:\n self.metadata = self.metadata.sample(frac=pct_subset, random_state=seed1)\n if balance:\n reals = self.metadata[self.metadata.label=='REAL']\n self.num_reals = len(reals)\n fakes = self.metadata[self.metadata.label=='FAKE']\n fakes = fakes.sample(n=self.num_reals, random_state=seed2)\n self.metadata = pd.concat([reals,fakes])\n\n self.num_subbursts = num_subbursts\n self.transform = transform\n self.padding = PADDING_CROP\n self.random_start_points = random_start_points","def make_data_splits(samples, params, RESULTSDIR, num_experiments):\n # TODO: Switch to .mat from .pickle so that these lists are easier to read\n # and change.\n\n partition = {}\n if params[\"load_valid\"] is None:\n # Set random seed if included in params\n if params[\"data_split_seed\"] is not None:\n np.random.seed(params[\"data_split_seed\"])\n\n all_inds = np.arange(len(samples))\n\n # extract random inds from each set for validation\n v = params[\"num_validation_per_exp\"]\n valid_inds = []\n if params[\"valid_exp\"] is not None and params[\"num_validation_per_exp\"] > 0:\n all_valid_inds = []\n for e in params[\"valid_exp\"]:\n tinds = [\n i for i in range(len(samples)) if int(samples[i].split(\"_\")[0]) == e\n ]\n all_valid_inds = all_valid_inds + tinds\n valid_inds = valid_inds + list(\n np.random.choice(tinds, (v,), replace=False)\n )\n valid_inds = list(np.sort(valid_inds))\n\n train_inds = list(set(all_inds) - set(all_valid_inds))#[i for i in all_inds if i not in all_valid_inds]\n elif params[\"num_validation_per_exp\"] > 0: # if 0, do not perform validation\n for e in range(num_experiments):\n tinds = [\n i for i in range(len(samples)) if int(samples[i].split(\"_\")[0]) == e\n ]\n valid_inds = valid_inds + list(\n np.random.choice(tinds, (v,), replace=False)\n )\n valid_inds = list(np.sort(valid_inds))\n\n train_inds = [i for i in all_inds if i not in valid_inds]\n elif params[\"valid_exp\"] is not None:\n raise Exception(\"Need to set num_validation_per_exp in using valid_exp\")\n else:\n train_inds = all_inds\n\n assert (set(valid_inds) & set(train_inds)) == set()\n\n train_samples = samples[train_inds]\n train_inds = []\n if params[\"valid_exp\"] is not None:\n train_expts = [f for f in range(num_experiments) if f not in params[\"valid_exp\"]]\n else:\n train_expts = np.arange(num_experiments)\n\n print(\"TRAIN EXPTS: {}\".format(train_expts))\n\n if params[\"num_train_per_exp\"] is not None:\n # Then sample randomly without replacement from training sampleIDs\n for e in train_expts:\n tinds = [\n i for i in range(len(train_samples)) if int(train_samples[i].split(\"_\")[0]) == e\n ]\n print(e)\n print(len(tinds))\n train_inds = train_inds + list(\n np.random.choice(tinds, (params[\"num_train_per_exp\"],), replace=False)\n )\n train_inds = list(np.sort(train_inds))\n else:\n train_inds = np.arange(len(train_samples))\n\n \n\n partition[\"valid_sampleIDs\"] = samples[valid_inds]\n partition[\"train_sampleIDs\"] = train_samples[train_inds]\n\n # Save train/val inds\n with open(os.path.join(RESULTSDIR, \"val_samples.pickle\"), \"wb\") as f:\n cPickle.dump(partition[\"valid_sampleIDs\"], f)\n\n with open(os.path.join(RESULTSDIR, \"train_samples.pickle\"), \"wb\") as f:\n cPickle.dump(partition[\"train_sampleIDs\"], f)\n else:\n # Load validation samples from elsewhere\n with open(os.path.join(params[\"load_valid\"], \"val_samples.pickle\"), \"rb\",) as f:\n partition[\"valid_sampleIDs\"] = cPickle.load(f)\n partition[\"train_sampleIDs\"] = [\n f for f in samples if f not in partition[\"valid_sampleIDs\"]\n ]\n\n # Reset any seeding so that future batch shuffling, etc. are not tied to this seed\n if params[\"data_split_seed\"] is not None:\n np.random.seed()\n\n return partition","def _create_examples_split(self, lines, set_type):\n examples = []\n \n for (i, line) in enumerate(lines):\n a_label = int(line[\"label\"])\n q_type = line[\"type\"]\n if a_label == 0 and q_type != \"qLookup\":\n #print(\"discontinue\")\n continue\n sentence_number = 0\n premise_text = line[\"premise\"]\n the_id = int(line[\"id\"])\n modified_premise_text = re.sub(self.stage_name_pattern,\"\",premise_text)\n modified_premise_text = re.sub(self.w_patterns,\"\",modified_premise_text)\n hypothesis_text = line[\"hypothesis\"]\n hypothesis_text = re.sub(self.w_patterns,\"\",hypothesis_text)\n \n\n sentences = modified_premise_text.split('.')\n\n for j, sentence in enumerate(sentences):\n guid = \"\" + str(sentence_number) + \"\\t\" + str(i) + \"\\t\" + str(len(sentences)) + \"\\t\" + str(a_label)\n text_a = sentence\n text_b = hypothesis_text\n label = a_label\n sentence_number += 1\n examples.append(\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n #print(\"16th sentence::\",sentences[16])\n\n return examples","def generate_complex_catalog(stem: str = '') -> cat.Catalog:\n group_a = generators.generate_sample_model(cat.Group, True)\n group_a.id = f'{stem}a'\n group_a.controls = generate_control_list(group_a.id, 4)\n part = generators.generate_sample_model(common.Part)\n part.id = f'{stem}a-1_smt'\n part.parts = None\n group_a.controls[0].parts[0].id = f'{stem}_part_with_subpart'\n group_a.controls[0].parts[0].parts = [part]\n group_b = generators.generate_sample_model(cat.Group, True)\n group_b.id = f'{stem}b'\n group_b.controls = generate_control_list(group_b.id, 3)\n group_b.controls[2].controls = generate_control_list(f'{group_b.id}-2', 3)\n group_ba = generators.generate_sample_model(cat.Group, True)\n group_ba.id = f'{stem}ba'\n group_ba.controls = generate_control_list(group_ba.id, 2)\n group_b.groups = [group_ba]\n\n catalog = generators.generate_sample_model(cat.Catalog, True)\n catalog.controls = generate_control_list(f'{stem}cat', 3)\n catalog.params = generate_param_list(f'{stem}parm', 3)\n\n test_control = generators.generate_sample_model(cat.Control, False)\n test_control.id = f'{stem}test-1'\n test_control.params = [common.Parameter(id=f'{test_control.id}_prm_1', values=['Default', 'Values'])]\n test_control.parts = [\n common.Part(\n id=f'{test_control.id}-stmt', prose='The prose with {{ insert: param, test-1_prm_1 }}', name='statement'\n )\n ]\n catalog.controls.append(test_control)\n catalog.groups = [group_a, group_b]\n\n return catalog","def create_new_individuals(design, problem, pop_size=None):\n\n if pop_size is None:\n pop_size_options = [50, 105, 120, 126, 132, 112, 156, 90, 275]\n pop_size = pop_size_options[problem.num_of_objectives - 2]\n\n if design == \"RandomDesign\":\n lower_limits = np.asarray(problem.get_variable_lower_bounds())\n upper_limits = np.asarray(problem.get_variable_upper_bounds())\n individuals = np.random.random((pop_size, problem.n_of_variables))\n # Scaling\n individuals = individuals * (upper_limits - lower_limits) + lower_limits\n\n return individuals\n\n elif design == \"LHSDesign\":\n lower_limits = np.asarray(problem.get_variable_lower_bounds())\n upper_limits = np.asarray(problem.get_variable_upper_bounds())\n individuals = lhs(problem.n_of_variables, samples=pop_size)\n # Scaling\n individuals = individuals * (upper_limits - lower_limits) + lower_limits\n\n return individuals\n\n elif design == \"EvoNN\":\n\n \"\"\"Create a population of neural networks for the EvoNN algorithm.\n\n Individuals are 2d arrays representing the weight matrices of the NNs.\n One extra row is added for bias.\n\n \"\"\"\n\n w_low = problem.params[\"w_low\"]\n w_high = problem.params[\"w_high\"]\n in_nodes = problem.num_of_variables\n num_nodes = problem.params[\"num_nodes\"]\n prob_omit = problem.params[\"prob_omit\"]\n\n individuals = np.random.uniform(\n w_low, w_high, size=(pop_size, in_nodes, num_nodes)\n )\n\n # Randomly set some weights to zero\n zeros = np.random.choice(\n np.arange(individuals.size), ceil(individuals.size * prob_omit)\n )\n individuals.ravel()[zeros] = 0\n\n # Set bias\n individuals = np.insert(individuals, 0, 1, axis=1)\n\n return individuals\n\n elif design == \"EvoDN2\":\n \"\"\"Create a population of deep neural networks (DNNs) for the EvoDN2 algorithm.\n\n Each individual is a list of subnets, and each subnet contains a random amount\n of layers and\n nodes per layer. The subnets are evolved via evolutionary algorithms, and they\n converge\n on the final linear layer of the DNN.\n \"\"\"\n\n individuals = []\n for i in range(problem.params[\"pop_size\"]):\n nets = []\n for j in range(problem.params[\"num_subnets\"]):\n\n layers = []\n num_layers = np.random.randint(1, problem.params[\"max_layers\"])\n in_nodes = len(problem.subsets[j])\n\n for k in range(num_layers):\n out_nodes = random.randint(2, problem.params[\"max_nodes\"])\n net = np.random.uniform(\n problem.params[\"w_low\"],\n problem.params[\"w_high\"],\n size=(in_nodes, out_nodes),\n )\n # Randomly set some weights to zero\n zeros = np.random.choice(\n np.arange(net.size),\n ceil(net.size * problem.params[\"prob_omit\"]),\n )\n net.ravel()[zeros] = 0\n\n # Add bias\n net = np.insert(net, 0, 1, axis=0)\n in_nodes = out_nodes\n layers.append(net)\n\n nets.append(layers)\n\n individuals.append(nets)\n\n return individuals\n\n elif design == \"BioGP\":\n return problem.create_individuals()","def gen_submodels(self, model, options):\n for submodel in options:\n model.submodels.create(id=submodel)","def new_multi_experiments_from_components(self, dataset_params,\n input_params,\n architecture, model_params,\n train_params=None):\n # Assuming they're all list\n components = [dataset_params, input_params, architecture, model_params,\n train_params if train_params else [None]]\n args_list = product(*components)\n\n inserted_ids = []\n for args in args_list:\n inserted_ids.append(\n self.new_multi_experiments_from_components(*args))\n return inserted_ids","def three_experiments_branch_same_name_trials(\n three_experiments_branch_same_name, orionstate, storage\n):\n exp1 = experiment_builder.build(name=\"test_single_exp\", version=1, storage=storage)\n exp2 = experiment_builder.build(name=\"test_single_exp\", version=2, storage=storage)\n exp3 = experiment_builder.build(\n name=\"test_single_exp_child\", version=1, storage=storage\n )\n\n x = {\"name\": \"/x\", \"type\": \"real\"}\n y = {\"name\": \"/y\", \"type\": \"real\"}\n z = {\"name\": \"/z\", \"type\": \"real\"}\n x_value = 0.0\n for status in Trial.allowed_stati:\n x[\"value\"] = x_value + 0.1 # To avoid duplicates\n y[\"value\"] = x_value * 10\n z[\"value\"] = x_value * 100\n trial1 = Trial(experiment=exp1.id, params=[x], status=status)\n trial2 = Trial(experiment=exp2.id, params=[x, y], status=status)\n trial3 = Trial(experiment=exp3.id, params=[x, y, z], status=status)\n # Add a child to a trial from exp1\n child = trial1.branch(params={\"/x\": 1})\n orionstate.database.write(\"trials\", trial1.to_dict())\n orionstate.database.write(\"trials\", trial2.to_dict())\n orionstate.database.write(\"trials\", trial3.to_dict())\n orionstate.database.write(\"trials\", child.to_dict())\n x_value += 1\n # exp1 should have 12 trials (including child trials)\n # exp2 and exp3 should have 6 trials each\n\n # Add some algo data for exp1\n orionstate.database.read_and_write(\n collection_name=\"algo\",\n query={\"experiment\": exp1.id},\n data={\n \"state\": pickle.dumps(\n {\"my_algo_state\": \"some_data\", \"my_other_state_data\": \"some_other_data\"}\n )\n },\n )","def split(self, fractions=[0.8, 0.2]):\n\n if sum(fractions) > 1.0 or sum(fractions) <= 0:\n raise ValueError(\"the sum of fractions argument should be between 0 and 1\")\n\n # random indices\n idx = np.arange(self.n_samples)\n np.random.shuffle(idx)\n\n # insert zero\n fractions.insert(0, 0)\n\n # gte limits of the subsets\n limits = (np.cumsum(fractions) * self.n_samples).astype(np.int32)\n\n subsets = []\n # create output dataset\n for i in range(len(fractions) - 1):\n subsets.append(\n Dataset(self.inputs[idx[limits[i]:limits[i + 1]]], self.targets[idx[limits[i]:limits[i + 1]]]))\n\n return subsets","def init_subgroups(metadata):\n dictionary = {'dataframe': metadata}\n subgroups = [dictionary]\n\n return subgroups","def experiment(worker):\n if worker == 0:\n logging.info('Start.')\n\n surv = np.zeros((NUM_GEN, NUM_CRS, 2), dtype=float)\n # order = np.zeros((NUM_GEN, NUM_CRS, NUM_G), dtype=float) # time + orders\n ctrl = np.zeros((NUM_GEN, NUM_LIN, 2), dtype=float)\n\n # Initiation of lineages\n ancestor = Generation(species=SPECIES, N=NUM_INDV, environment=ENVIRONMENT)\n ancestor.natural_selection()\n lineages = [deepcopy(ancestor) for _ in range(NUM_LIN)]\n\n if worker == 0:\n logging.info('Lineages are initiated.')\n\n # BUG: Need to run analysis for the ancestral population!\n\n # Evolution\n for t in range(NUM_GEN):\n for i in range(NUM_LIN):\n lineages[i] = lineages[i].next_generation()\n lineages[i].natural_selection()\n\n # Control group of survival percentage\n population = deepcopy(lineages[i])\n offspring = population.next_generation(num=NUM_HYB)\n offspring.natural_selection()\n ctrl[t, i] = [t+1, offspring.survival_rate()]\n\n # Hybrids\n for j in range(NUM_CRS):\n idx_1, idx_2 = sample(range(len(lineages)), 2)\n lin_1, lin_2 = deepcopy(lineages[idx_1]), deepcopy(lineages[idx_2])\n hybrids = lin_1.hybrids(lin_2, num=NUM_HYB, env=ENVIRONMENT)\n hybrids.natural_selection()\n\n # Survival percentage\n surv[t, j] = [t+1, hybrids.survival_rate()]\n\n # Order of incompatibilities\n counting = {_ord: 0 for _ord in range(1, NUM_G)}\n inviable = [hybrids.members[i]\\\n for i, survived in enumerate(hybrids.survival)\\\n if not survived]\n for indv in inviable:\n for l, n in indv.incompatibility(**ENVIRONMENT).items():\n counting[l-1] += n\n order[t, j] = [t+1] + [counting[_ord]/float(NUM_HYB)\\\n for _ord in range(1, NUM_G)]\n\n if worker == 0:\n logging.info('Generation {} is done.'.format(t+1))\n\n return (surv.reshape((NUM_GEN*NUM_CRS, 2)).tolist(),\\\n # order.reshape((NUM_GEN*NUM_CRS, NUM_G)).tolist(),\\\n ctrl.reshape((NUM_GEN*NUM_LIN, 2)).tolist())","def split_dataset(df_playlists, df_interactions):\n df_train_pl, cat_pids = generate_train(df_playlists)\n df_test_pl, df_test_itr, df_eval_itr, df_train_itr = generate_test(cat_pids, df_playlists, df_interactions)\n\n return df_train_pl, df_train_itr, df_test_pl, df_test_itr, df_eval_itr","def tenpar_subset_test():\n model_d = \"ies_10par_xsec\"\n test_d = os.path.join(model_d, \"master_subset_test\")\n template_d = os.path.join(model_d, \"test_template\")\n if not os.path.exists(template_d):\n raise Exception(\"template_d {0} not found\".format(template_d))\n if os.path.exists(test_d):\n shutil.rmtree(test_d)\n # shutil.copytree(base_d,test_d)\n pst = pyemu.Pst(os.path.join(template_d, \"pest.pst\"))\n pst.control_data.noptmax = 3\n\n # first without subset\n pst.pestpp_options = {}\n pst.pestpp_options[\"ies_num_reals\"] = 50\n pst.pestpp_options[\"ies_lambda_mults\"] = \"1.0\"\n pst.pestpp_options[\"ies_accept_phi_fac\"] = 100.0\n pst.write(os.path.join(template_d, \"pest.pst\"))\n pyemu.helpers.start_slaves(template_d, exe_path, \"pest.pst\", num_slaves=10,\n slave_root=model_d, master_dir=test_d)\n df_base = pd.read_csv(os.path.join(test_d, \"pest.phi.meas.csv\"),index_col=0)\n\n pst.pestpp_options = {}\n pst.pestpp_options[\"ies_num_reals\"] = 50\n pst.pestpp_options[\"ies_lambda_mults\"] = \"1.0\"\n pst.pestpp_options[\"ies_subset_size\"] = 15\n pst.pestpp_options[\"ies_accept_phi_fac\"] = 100.0\n\n pst.write(os.path.join(template_d, \"pest.pst\"))\n pyemu.helpers.start_slaves(template_d, exe_path, \"pest.pst\", num_slaves=10,\n slave_root=model_d, master_dir=test_d)\n df_sub = pd.read_csv(os.path.join(test_d, \"pest.phi.meas.csv\"),index_col=0)\n diff = (df_sub - df_base).apply(np.abs)\n print(diff.max())\n print(df_sub.iloc[-1,:])\n print(df_base.iloc[-1,:])\n assert diff.max().max() == 0.0","def _subsample(self, hidden, explore, search_space, names, representations, output, description, outer_i=None):\n name = search_space.name\n names = copy.deepcopy(names)\n names.append(name)\n # Those checks were introduced to reuse this method to evaluate model output for already existing description.\n if description.get(name) is None:\n description[name] = {}\n\n # region num inner prediction\n num_inner = self.search_space.eval_(search_space.num_inner, **locals())\n\n # region forcing facilitation\n if description.get(f'num_{name}') is None:\n forced_inner = self.search_space.eval_(search_space.forced_num_inner, **locals())\n max_available = max(num_inner) if isinstance(num_inner, (list, tuple)) else num_inner\n assert forced_inner is None or isinstance(forced_inner, int) and 0 < forced_inner <= max_available\n\n if forced_inner is not None:\n try: forced_inner = num_inner.index(forced_inner)\n except ValueError:\n raise ValueError(f'Number of inner search spaces \"{forced_inner}\" '\n 'is not present in original search space.')\n else:\n forced_inner = num_inner.index(description[f'num_{name}'])\n # endregion\n\n index = self.embedding_index[f'{name}_start']\n index = wrap([index], self.device, dtype=torch.long)\n input = self.embedding(index)\n\n if len(num_inner) > 1:\n key = f'{\"_\".join(names[:-1])}_{len(num_inner)}_{name}s'\n action, hidden = self.act(input, hidden, explore, key, output, forced_inner)\n num_inner = num_inner[action.item()]\n else:\n hidden = self(input, hidden)\n num_inner = num_inner[forced_inner] if forced_inner is not None else num_inner[0]\n\n if description.get(f'num_{name}') is None:\n description[f'num_{name}'] = num_inner\n # endregion\n\n # region inner space prediction\n index = self.embedding_index[f'{num_inner}_{name}s']\n index = wrap([index], self.device, dtype=torch.long)\n input = self.embedding(index)\n\n encoded_flag = False\n for i in range(int(num_inner)):\n if description[name].get(i) is None:\n description[name][i] = {}\n\n if isinstance(search_space.inner, dict):\n for k, v in search_space.inner.items():\n v = self.search_space.eval_(v, **locals())\n key = f'{\"_\".join(names[:-1])}_{len(v)}_{k}s'\n\n if isinstance(v, (list, tuple)) and len(v) > 1:\n pick = description[name][i].get(k)\n if pick is not None:\n try: pick = v.index(pick)\n except ValueError:\n raise ValueError(f'Point \"{pick}\" is not present in '\n f'{k} dimension of the search space.')\n\n action, hidden = self.act(input, hidden, explore, key, output, pick)\n\n choice = v[action.item()]\n\n if pick is None: description[name][i][k] = choice\n else: assert choice == description[name][i][k]\n\n if k == 'id':\n if choice in representations:\n input = representations[choice]\n continue\n\n index = self.embedding_index[f'{k}_{choice}']\n index = wrap([index], self.device, dtype=torch.long)\n input = self.embedding(index)\n else:\n if description[name][i].get(k) is None:\n description[name][i][k] = v[0]\n else: assert v[0] == description[name][i][k]\n\n else:\n assert isinstance(search_space.inner, (list, tuple, SearchSpace)), \\\n 'Inner search space must be either dict, SearchSpace or list of SearchSpaces.'\n\n if not encoded_flag:\n hidden = self(input, hidden)\n encoded_flag = True\n\n spaces = [search_space.inner] if isinstance(search_space.inner, SearchSpace) else search_space.inner\n for space in spaces:\n input = self._subsample(hidden, explore, space, names, representations,\n output, description[name][i], i)\n hidden = self(input[-1][0], hidden)\n\n index = self.embedding_index[f'{name}_inner_done']\n index = wrap([index], self.device, dtype=torch.long)\n input = self.embedding(index)\n # endregion\n\n # region outer keys prediction\n for k, v in search_space.outer.items():\n v = self.search_space.eval_(v, **locals())\n key = f'{\"_\".join(names[:-1])}_{len(v)}_{k}s'\n\n if isinstance(v, (list, tuple)) and len(v) > 1:\n pick = description.get(k)\n if pick is not None:\n try: pick = v.index(pick)\n except ValueError:\n raise ValueError(f'Point \"{pick}\" is not present in '\n f'{k} dimension of the search space.')\n\n action, hidden = self.act(input, hidden, explore, key, output, pick)\n\n choice = v[action.item()]\n\n if pick is None: description[k] = choice\n else: assert choice == description[k]\n\n if k == 'id':\n if choice in representations:\n input = representations[choice]\n continue\n\n index = self.embedding_index[f'{k}_{choice}']\n index = wrap([index], self.device, dtype=torch.long)\n input = self.embedding(index)\n else:\n if description[name][i].get(k) is None:\n description[name][i][k] = v[0]\n else: assert v[0] == description[name][i][k]\n # endregion\n\n index = self.embedding_index[f'{name}_end']\n index = wrap([index], self.device, dtype=torch.long)\n input = self.embedding(index)\n\n hidden = self(input, hidden)\n if len(names) > 2:\n repr_key = f'{names[-2]}' if outer_i is None else f'{names[-2]}_{outer_i}'\n representations[repr_key] = hidden[-1][0]\n return hidden","def split(self, train_fraction=0.8, val_fraction=0.2, test_fraction=0, seed=1):\n if self.is_initialized():\n return\n self.ensure_fraction_sum(train_fraction, val_fraction, test_fraction)\n np.random.seed(seed)\n self.samples = sorted(self.samples)\n np.random.shuffle(self.samples)\n train_idx = ceil(train_fraction*(len(self.samples)))\n val_idx = train_idx + ceil(val_fraction*(len(self.samples)))\n test_idx = val_idx + ceil(test_fraction*(len(self.samples)))\n indices = list(range(len(self.samples)))\n self.indices[TRAIN_SUBSET] = indices[:train_idx]\n self.indices[VAL_SUBSET] = indices[train_idx:val_idx]\n self.indices[TEST_SUBSET] = indices[val_idx:test_idx]","def createSubListOfSpeciesFeatures(self):\n return _libsbml.MultiSpeciesPlugin_createSubListOfSpeciesFeatures(self)","def test_metabolite_production(submodel, reaction_bounds, pseudo_reactions=None, \n test_producibles=None, test_recyclables=None):\n if test_producibles:\n reactants = test_producibles\n else: \n reactants = []\n for reaction in submodel.dfba_obj.expression.reactions:\n for reactant in reaction.get_reactants():\n if reactant.id not in reactants:\n reactants.append(reactant.id)\n \n if test_recyclables:\n products = test_recyclables\n else: \n products = []\n for reaction in submodel.dfba_obj.expression.reactions:\n for product in reaction.get_products():\n if product.id not in products:\n products.append(product.id)\n\n if pseudo_reactions:\n excluded_rxns = pseudo_reactions\n else:\n excluded_rxns = [] \n\n conv_model = conv_opt.Model(name='model')\n conv_variables = {}\n conv_metabolite_matrices = collections.defaultdict(list)\n for reaction in submodel.reactions:\n if reaction.id not in excluded_rxns:\n conv_variables[reaction.id] = conv_opt.Variable(\n name=reaction.id, type=conv_opt.VariableType.continuous,\n lower_bound=reaction_bounds[reaction.id][0], \n upper_bound=reaction_bounds[reaction.id][1])\n conv_model.variables.append(conv_variables[reaction.id])\n for part in reaction.participants:\n conv_metabolite_matrices[part.species.id].append(\n conv_opt.LinearTerm(conv_variables[reaction.id], \n part.coefficient)) \n\n for met_id, expression in conv_metabolite_matrices.items():\n conv_model.constraints.append(conv_opt.Constraint(expression, name=met_id, \n upper_bound=0.0, lower_bound=0.0)) \n \n obj_reactants = {}\n for reactant in reactants: \n obj_reaction = conv_opt.Variable(name=reactant + '_test_reaction', \n type=conv_opt.VariableType.continuous,\n lower_bound=0.0)\n obj_reactants[reactant] = obj_reaction\n conv_model.variables.append(obj_reaction)\n expression = [i for i in conv_model.constraints if i.name==reactant]\n if expression:\n expression[0].terms.append(conv_opt.LinearTerm(obj_reaction, -1.))\n else:\n conv_model.constraints.append(conv_opt.Constraint(\n [conv_opt.LinearTerm(obj_reaction, -1.)], name=reactant, \n upper_bound=0.0, lower_bound=0.0))\n \n obj_products = {}\n for product in products: \n obj_reaction = conv_opt.Variable(name=product + '_test_reaction', \n type=conv_opt.VariableType.continuous,\n lower_bound=0.0)\n obj_products[product] = obj_reaction\n conv_model.variables.append(obj_reaction)\n expression = [i for i in conv_model.constraints if i.name==product]\n if expression:\n expression[0].terms.append(conv_opt.LinearTerm(obj_reaction, 1.))\n else:\n conv_model.constraints.append(conv_opt.Constraint(\n [conv_opt.LinearTerm(obj_reaction, 1.)], name=product, \n upper_bound=0.0, lower_bound=0.0))\n\n conv_model.objective_direction = conv_opt.ObjectiveDirection.maximize\n\n options = conv_opt.SolveOptions(\n solver=conv_opt.Solver.cplex,\n presolve=conv_opt.Presolve.on,\n solver_options={\n 'cplex': {\n 'parameters': {\n 'emphasis': {\n 'numerical': 1,\n },\n 'read': {\n 'scale': 1,\n },\n },\n },\n })\n\n unproducibles = []\n for reactant in reactants:\n obj_reaction = obj_reactants[reactant]\n conv_model.objective_terms = [conv_opt.LinearTerm(obj_reaction, 1.),]\n result = conv_model.solve()\n if result.value == 0.0:\n unproducibles.append(reactant)\n\n unrecyclables = []\n for product in products:\n obj_reaction = obj_products[product]\n conv_model.objective_terms = [conv_opt.LinearTerm(obj_reaction, 1.),]\n result = conv_model.solve()\n if result.value == 0.0:\n unrecyclables.append(product) \n\n return unproducibles, unrecyclables","def __getitem__(self, type: str):\n nodes = pandas.read_csv(join(self.base_path, \"nodes.csv\"))\n edges = pandas.read_csv(join(self.base_path, \"held.csv\"))\n if type == \"link\":\n # nodes = pandas.read_csv(join(self.base_path, \"nodes.csv\"))\n held = pandas.read_csv(join(self.base_path, \"held.csv\"))\n\n held = held.query('type == 8')[['src', 'dst']]\n\n # node_pool = set(self.splits[2])\n # held = keep_from_set(held, node_pool)\n\n return Experiment(self.embed, nodes, edges, held, split_on=\"nodes\", neg_sampling_strategy=\"word2vec\", compact_dst=False)\n\n elif type == \"apicall\":\n api_seq = pandas.read_csv(self.experiments['apicall'])\n\n # unique_nodes = set(nodes['id'].values.tolist())\n\n # api_seq_test = api_seq.copy()\n # api_seq_test['src'] = api_seq_test['src'].apply(lambda nid: nid if nid in unique_nodes else None)\n # api_seq_test['dst'] = api_seq_test['dst'].apply(lambda nid: nid if nid in unique_nodes else None)\n # api_seq_test.dropna(axis=0, inplace=True)\n\n # disabled for testing\n # api_seq = api_seq[\n # api_seq['src'].apply(lambda nid: nid in unique_nodes)\n # ]\n #\n # api_seq = api_seq[\n # api_seq['dst'].apply(lambda nid: nid in unique_nodes)\n # ]\n\n node_pool = set(self.splits[2])\n api_seq = keep_from_set(api_seq, node_pool)\n\n return Experiment(self.embed, nodes, edges, api_seq, split_on=\"nodes\", neg_sampling_strategy=\"word2vec\", compact_dst=False)\n\n elif type == \"typeuse\":\n held = pandas.read_csv(join(self.base_path, \"held.csv\"))\n\n held = held.query('type == 2')[['src', 'dst']]\n\n # node_pool = set(self.splits[2])\n # held = keep_from_set(held, node_pool)\n\n return Experiment(self.embed, nodes, edges, held, split_on=\"nodes\", neg_sampling_strategy=\"word2vec\", compact_dst=False)\n\n elif type == \"varuse\":\n var_use = pandas.read_csv(self.experiments['varuse'])\n\n # unique_nodes = set(nodes['id'].values.tolist())\n node_pool = set(self.splits[2])\n\n var_use = var_use[\n var_use['src'].apply(lambda nid: nid in node_pool)\n ]\n\n return Experiment2(self.embed, nodes, edges, var_use, split_on=\"nodes\", neg_sampling_strategy=\"word2vec\")\n\n elif type == \"fname\":\n\n # fname = pandas.read_csv(self.experiments['fname'])\n functions = nodes.query('label == 4096')\n functions['fname'] = functions['name'].apply(lambda name: name.split(\".\")[-1])\n\n functions['src'] = functions['id']\n functions['dst'] = functions['fname']\n\n # unique_nodes = set(nodes['id'].values.tolist())\n node_pool = set(self.splits[2])\n\n functions = functions[\n functions['src'].apply(lambda nid: nid in node_pool)\n ]\n\n # use edge splits when outgoing degree is 1\n\n return Experiment2(self.embed, nodes, edges, functions[['src', 'dst']], split_on=\"edges\", neg_sampling_strategy=\"word2vec\")\n\n elif type == \"nodetype\":\n\n types = nodes.copy()\n types['src'] = nodes['id']\n types['dst'] = nodes['label']\n\n print(\"WARNING: Make sure that you target label is stored in the field: label\")\n # raise Warning(\"Make sure that you target label is stored in the field: label\")\n\n node_pool = set(self.splits[2])\n\n types['src'] = types['src'].apply(lambda nid: nid if nid in node_pool else None)\n types = types.dropna(axis=0)\n\n return Experiment3(self.embed, nodes, edges, types[['src', 'dst']], split_on=\"edges\", neg_sampling_strategy=\"word2vec\")\n else:\n raise ValueError(f\"Unknown experiment: {type}. The following experiments are available: [apicall|link|typeuse|varuse|fname|nodetype].\")","def test_processes_per_experiment():\n # Create a script with 4 experiments.\n template_script = get_template_script()\n template_script['experiment1'] = copy.deepcopy(template_script['experiments'])\n template_script['experiment1']['system'] = utils.CombinatorialLeaf(['explicit-system', 'implicit-system'])\n # The first two experiments have less number of states than the other two.\n template_script['experiment1']['protocol'] = 'hydration-protocol'\n template_script['experiment2'] = copy.deepcopy(template_script['experiments'])\n template_script['experiment2']['system'] = 'hydration-system'\n # The last experiment uses SAMS.\n template_script['experiment2']['sampler'] = utils.CombinatorialLeaf(['repex', 'sams'])\n template_script['experiments'] = ['experiment1', 'experiment2']\n\n exp_builder = ExperimentBuilder(template_script)\n experiments = list(exp_builder._expand_experiments())\n\n # The default is auto.\n assert exp_builder._options['processes_per_experiment'] == 'auto'\n\n # When there is no MPI environment the calculation is serial.\n assert exp_builder._get_experiment_mpi_group_size(experiments) is None\n\n # In an MPI environment, the MPI communicator is split according\n # to the number of experiments still have to be completed. Each\n # test case is pair (experiments, MPICOMM size, expected return value).\n test_cases = [\n (experiments, 5, 1), # This contains a SAMS sampler so only 1 MPI process is used.\n (experiments[:-1], 4, [1, 1, 2]), # 3 repex samples, but last experiment has more intermediate states.\n (experiments[1:-1], 4, [2, 2]), # 2 repex samples on 4 MPI processes.\n (experiments[1:-1], 6, [3, 3]), # 2 repex samples on 4 MPI processes.\n (list(reversed(experiments[1:-1])), 3, [2, 1]), # 2 repex samples on 3 MPI processes.\n (experiments[:-1], 2, 1), # Less MPI processes than experiments, split everything.\n ]\n\n for i, (exp, mpicomm_size, expected_result) in enumerate(test_cases):\n with mpiplus.mpiplus._simulated_mpi_environment(size=mpicomm_size):\n result = exp_builder._get_experiment_mpi_group_size(exp)\n err_msg = ('experiments: {}\\nMPICOMM size: {}\\nexpected result: {}'\n '\\nresult: {}').format(*test_cases[i], result)\n assert result == expected_result, err_msg\n\n # Test manual setting of processes_per_experiments.\n test_cases = [2, None]\n for processes_per_experiment in test_cases:\n exp_builder._options['processes_per_experiment'] = processes_per_experiment\n # Serial execution is always None.\n assert exp_builder._get_experiment_mpi_group_size(experiments) is None\n with mpiplus.mpiplus._simulated_mpi_environment(size=5):\n assert exp_builder._get_experiment_mpi_group_size(experiments[:-1]) == processes_per_experiment\n # When there are SAMS sampler, it's always 1.\n assert exp_builder._get_experiment_mpi_group_size(experiments) == 1","def get_subtechniques_of():\n global subtechniques_of\n\n if not subtechniques_of:\n subtechniques_of = rsh.subtechniques_of(get_srcs())\n \n return subtechniques_of","def setup(cls):\n cls.logger = logging.getLogger('ModelTestLogger')\n cls.logger.setLevel(logging.DEBUG)\n\n s1 = model.Subject('subject1')\n s2 = model.Subject('subject2')\n\n cls.experiment = model.Experiment()\n cls.experiment.put_subject(s1)\n cls.experiment.put_subject(s2)\n\n setup1 = model.Setup(cls.experiment)\n modality1 = model.Modality(setup1, 20, 'emg')\n modality2 = model.Modality(setup1, 5, 'kin')\n\n model.Channel(modality1, 'brachoradialis')\n model.Channel(modality1, 'musculus sterno clavicularis')\n model.Channel(modality1, 'musculus rhombideus')\n model.Channel(modality1, 'musculus lattisimus')\n\n model.Channel(modality2, 'Pos-X')\n model.Channel(modality2, 'Pos-Y')\n model.Channel(modality2, 'Pos-Z')\n\n session1 = model.Session(cls.experiment, setup1, s1, 'session1')\n arr = np.column_stack((\n np.tile(\n np.concatenate((\n np.arange(0., 1., 0.1),\n np.arange(1., 0., -0.1)\n )),\n 10\n ),\n np.tile(\n np.concatenate((\n np.arange(10),\n np.arange(10, 0, -1)\n )),\n 10\n ),\n np.tile(\n np.concatenate((\n np.arange(0.0, 0.1, 0.01),\n np.arange(0.1, 0.0, -0.01)\n )),\n 10\n ),\n np.tile(\n np.concatenate((\n np.arange(0.5, 1.5, 0.1),\n np.arange(1.5, 0.5, -0.1)\n )),\n 10\n ),\n ))\n recording1 = model.Recording(session1, modality1, data=arr,\n identifier='emg_recording1')\n\n arr2 = np.column_stack((\n np.sum(np.mean(arr.reshape(-1, 4, 4), axis=1), axis=1),\n np.prod(np.mean(arr.reshape(-1, 4, 4), axis=1), axis=1),\n np.square(np.sum(np.mean(arr.reshape(-1, 4, 4), axis=1), axis=1))\n ))\n recording2 = model.Recording(session1, modality2, data=arr2,\n identifier='kin_recording1')\n for i in range(5):\n model.Trial(recording1, i * 2, 2)\n model.Trial(recording2, i * 2, 2)\n\n session2 = model.Session(cls.experiment, setup1, s2, 'session2')\n arr = np.add(arr, np.random.randn(*arr.shape))\n recording1 = model.Recording(session2, modality1, data=arr,\n identifier='emg_recording2')\n arr2 = np.column_stack((\n np.sin(np.mean(np.sum(arr.reshape(-1, 4, 4), axis=1))),\n np.cos(np.mean(np.sum(arr.reshape(-1, 4, 4), axis=1))),\n np.tan(np.mean(np.sum(arr.reshape(-1, 4, 4), axis=1)))\n ))\n recording2 = model.Recording(session2, modality2, data=arr2,\n identifier='kin_recording2')\n for i in range(5):\n model.Trial(recording1, i * 2, 2)\n model.Trial(recording2, i * 2, 2)","def randomSubData(self, number): \n if number < 0 or number > self.__numExamples: \n raise ValueError(\"Random subset size must be between 0 and \" + str(self.__numExamples))\n \n self.__exampleIndices = array(sample(list(range(0, self.__numExamples)), number))","def subdivide_mesh(obj, n_subdiv=2):\n thisfunc = thisfile + '->subdivide_mesh()'\n\n scene = bpy.context.scene\n\n # All objects need to be in 'OBJECT' mode to apply modifiers -- maybe a Blender bug?\n for o in bpy.data.objects:\n scene.objects.active = o\n bpy.ops.object.mode_set(mode='OBJECT')\n o.select = False\n obj.select = True\n scene.objects.active = obj\n\n bpy.ops.object.modifier_add(type='SUBSURF')\n obj.modifiers['Subsurf'].subdivision_type = 'CATMULL_CLARK'\n obj.modifiers['Subsurf'].levels = n_subdiv\n obj.modifiers['Subsurf'].render_levels = n_subdiv\n\n # Apply modifier\n bpy.ops.object.modifier_apply(modifier='Subsurf', apply_as='DATA')\n\n # Scene update necessary, as matrix_world is updated lazily\n scene.update()\n\n logging.info(\"%s: Subdivided mesh of '%s'\", thisfunc, obj.name)","def split_dev(self):\n\t\tprint(\"Splitting test set into dev and test set\")\n\n\t\told_length = len(self.X[\"test\"])\n\t\tindices = list(range(old_length))\n\n\t\tnp.random.seed(0)\n\t\tnp.random.shuffle(indices)\n\t\t\n\t\tsplit = int(len(indices) * 0.5)\n\n\t\tsplit_indices = {\"test\": indices[:split], \"dev\": indices[split:]}\n\t\n\t\tfor dataset in (\"dev\", \"test\"):\n\t\t\tself.X[dataset] = [self.X[\"test\"][idx] for idx in split_indices[dataset]]\n\t\t\tself.Y[dataset] = [self.Y[\"test\"][idx] for idx in split_indices[dataset]]\n\t\t\tself.raw_documents[dataset] = [self.raw_documents[\"test\"][idx] for idx in split_indices[dataset]]\n\t\t\tself.tokenized_documents[dataset] = [self.tokenized_documents[\"test\"][idx] for idx in split_indices[dataset]]\n\t\t\n\t\tprint(\"Split test set with\", old_length, \"samples into\", len(self.X[\"test\"]), \"/\", len(self.X[\"dev\"]), \"samples\")","def make_train_devel_test_split(data: Iterable, ratio: str) -> (Iterable, Iterable, Iterable):\n # Parse the splitting ratio\n train, devel, test = [int(x) for x in ratio.split(':')]\n\n # First split into training+development and test\n train_devel, _test = train_test_split(data, test_size=(test / (train + devel + test)))\n # Then split training+development into training and development\n _train, _devel = train_test_split(train_devel, test_size=(devel / (train + devel)))\n\n return _train, _devel, _test","def create_four_subplots():\n pass","def get_test_split(self, fraction=0.1):\n rng = np.random.default_rng(42)\n test_size = int(round(len(self.all_asset_ids) * fraction))\n test_ids = rng.choice(self.all_asset_ids, size=test_size, replace=False)\n train_ids = [i for i in self.all_asset_ids if i not in test_ids]\n return train_ids, test_ids","def build_multiple_datasets(\n template_dataset='ALLEN_st_cells_1_movies',\n template_experiment='ALLEN_st_selected_cells_1',\n model_structs='ALLEN_st_selected_cells_1',\n this_dataset_name='MULTIALLEN_',\n cluster=False,\n print_info=False,\n N=16):\n main_config = Allen_Brain_Observatory_Config()\n\n # Remove any BP-CC repos in the path\n bp_cc_paths = [\n x for x in sys.path if 'contextual' in x or 'Contextual' in x]\n [sys.path.remove(x) for x in bp_cc_paths]\n\n # Append the BP-CC repo to this python path\n if cluster:\n cc_path = main_config.cluster_cc_path\n else:\n cc_path = main_config.cc_path\n main_config.cc_data_dir = os.path.join(\n cc_path,\n 'dataset_processing') # Pass to encode_datasets.py\n sys.path.append(cc_path)\n import experiments # from BP-CC\n # from db import credentials\n exps = experiments.experiments()\n # db_config = credentials.postgresql_connection()\n\n # Query all neurons for an experiment setup\n queries = [ # MICHELE: ADD LOOP HERE\n [{ # DO THIS SEPARATELY\n 'rf_coordinate_range': { # Get all cells\n 'x_min': -10000,\n 'x_max': 10000,\n 'y_min': -10000,\n 'y_max': 10000,\n },\n 'structure': 'VISam',\n 'this_dataset_name': 'MULTIALLEN_VISam'\n }]\n ]\n filter_by_stim = [\n 'natural_movie_one',\n 'natural_movie_two'\n ]\n sessions = [\n 'three_session_C',\n 'three_session_C2'\n ]\n print 'Pulling cells by their RFs and stimulus: %s.' % filter_by_stim\n all_data_dicts = query_neurons_rfs(\n queries=queries,\n filter_by_stim=filter_by_stim,\n sessions=sessions)\n\n # Check if a weight sharing is needed\n assert len(flatten_list(all_data_dicts)) > 0, 'No cells in this query.'\n\n # Print cell information if requested\n if print_info:\n cre_lines = [x['cre_line'] for x in all_data_dicts[0]]\n cre_lines, cre_counts = np.unique(cre_lines, return_counts=True)\n cre_list = [(x, y) for x, y in zip(cre_lines, cre_counts)]\n print 'Found the following cre line promotors: %s' % json.dumps(\n cre_list)\n return\n\n # Prepare datasets\n dataset_method = declare_allen_datasets()[template_dataset]()\n if dataset_method['weight_sharing']:\n gridded_rfs, rf_size = create_grid_queries(all_data_dicts[0])\n if dataset_method['grid_query']:\n all_data_dicts = query_neurons_rfs(\n queries=gridded_rfs,\n filter_by_stim=filter_by_stim,\n sessions=sessions)\n all_data_dicts = [\n x for x in all_data_dicts if x != []] # Filter empties.\n downsample = dataset_method[\n 'process_stimuli']['natural_scenes']['resize'][0] /\\\n dataset_method['cc_repo_vars']['model_im_size'][0]\n filter_size = calculate_rf_size(\n rf_size=rf_size,\n downsample=downsample)\n else:\n filter_size = None\n\n # Declare the experiment template\n if dataset_method['st_conv']:\n # Dynamic dataset\n exp_method_template = os.path.join(\n main_config.exp_method_template_dir,\n '3d_exp_method_template.txt')\n else:\n # Static dataset\n exp_method_template = os.path.join(\n main_config.exp_method_template_dir,\n '2d_exp_method_template.txt')\n\n # Prepare directories\n model_directory = os.path.join(\n cc_path,\n 'models',\n 'structs')\n model_templates = glob(\n os.path.join(\n model_directory,\n model_structs,\n '*.py'))\n experiment_file = os.path.join(cc_path, 'experiments.py')\n\n # Loop through each query and build all possible datasets with template\n ts = get_dt_stamp()\n session_name = int(''.join(\n [random.choice(string.digits) for k in range(N//2)]))\n for ni, q in enumerate(all_data_dicts):\n assert len(q), 'Cell dictionary is empty.'\n meta_dir = os.path.join(\n main_config.multi_exps,\n '%s_cells_%s' % (len(q), ts))\n make_dir(meta_dir)\n if dataset_method['weight_sharing']:\n print 'Preparing dataset %s/%s.' % (\n ni,\n len(all_data_dicts))\n rf_grid = rf_extents(q)\n rf_dict = q[0]\n rf_dict['on_center_x_max'] = rf_grid['x_max']\n rf_dict['on_center_y_max'] = rf_grid['y_max']\n rf_dict['on_center_x'] = rf_grid['x_min']\n rf_dict['on_center_y'] = rf_grid['y_min']\n if 'this_dataset_name' in queries[ni][0].keys():\n this_dataset_name = queries[ni][0]['this_dataset_name']\n process_dataset(\n dataset_method=dataset_method,\n rf_dict=rf_dict,\n this_dataset_name=this_dataset_name,\n model_directory=model_directory,\n model_templates=model_templates,\n exps=exps,\n template_experiment=template_experiment,\n session_name=session_name,\n meta_dir=meta_dir,\n db_config=credentials, # db_config,\n experiment_file=experiment_file,\n main_config=main_config,\n idx=ni,\n cluster=cluster,\n filter_size=filter_size,\n exp_method_template=exp_method_template)\n else:\n for idx, rf_dict in enumerate(q):\n print 'Preparing dataset %s/%s in package %s/%s.' % (\n idx,\n len(q),\n ni,\n len(all_data_dicts))\n process_dataset(\n dataset_method=dataset_method,\n rf_dict=rf_dict,\n this_dataset_name=this_dataset_name,\n model_directory=model_directory,\n model_templates=model_templates,\n exps=exps,\n template_experiment=template_experiment,\n session_name=session_name,\n meta_dir=meta_dir,\n db_config=credentials, # db_config,\n experiment_file=experiment_file,\n main_config=main_config,\n idx=idx,\n cluster=cluster,\n exp_method_template=exp_method_template)","def create_samples_from_api(self, experiment: Experiment, platform_dict: Dict) -> List[Sample]:\n\n created_samples = []\n\n samples_endpoint = SAMPLES_URL.format(experiment.accession_code)\n r = utils.requests_retry_session().get(samples_endpoint, timeout=60)\n samples = r.json()[\"experiment\"][\"sample\"]\n\n # The SDRF is the complete metadata record on a sample/property basis.\n # We run this through our harmonizer and then attach the properties\n # to our created samples.\n SDRF_URL_TEMPLATE = \"https://www.ebi.ac.uk/arrayexpress/files/{code}/{code}.sdrf.txt\"\n sdrf_url = SDRF_URL_TEMPLATE.format(code=experiment.accession_code)\n sdrf_samples = harmony.parse_sdrf(sdrf_url)\n\n title_field = harmony.determine_title_field(sdrf_samples, samples)\n harmonized_samples = harmony.harmonize_all_samples(sdrf_samples, title_field)\n\n # An experiment can have many samples\n for sample_data in samples:\n\n # For some reason, this sample has no files associated with it.\n if \"file\" not in sample_data or len(sample_data[\"file\"]) == 0:\n continue\n\n # Each sample is given an experimenatlly-unique title.\n flat_sample = utils.flatten(sample_data)\n title = harmony.extract_title(flat_sample, title_field)\n\n # A sample may actually have many sub files.\n # If there is raw data, take that.\n # If not, take the derived.\n has_raw = False\n for sub_file in sample_data[\"file\"]:\n\n # For ex: E-GEOD-15645\n if isinstance(sub_file[\"comment\"], list):\n sub_file_mod = sub_file\n sub_file_mod[\"comment\"] = sub_file[\"comment\"][0]\n else:\n sub_file_mod = sub_file\n\n # Some have the 'data' field, but not the actual data\n # Ex: E-GEOD-9656\n if (\n sub_file_mod[\"type\"] == \"data\"\n and sub_file_mod[\"comment\"].get(\"value\", None) != None\n ):\n has_raw = True\n\n # 'value' can be None, convert to an empty string to\n # make it easier to use.\n comment_value = sub_file_mod[\"comment\"].get(\"value\", \"\") or \"\"\n if \"raw\" in comment_value:\n has_raw = True\n\n skip_sample = False\n for sub_file in sample_data[\"file\"]:\n\n # Don't get the raw data if it's only a 1-color sample.\n if \"Cy3\" in str(sample_data) and \"Cy5\" not in str(sample_data):\n has_raw = False\n\n # Skip derived data if we have it raw.\n if has_raw and \"derived data\" in sub_file[\"type\"]:\n continue\n\n download_url = None\n filename = sub_file[\"name\"]\n\n # sub_file[\"comment\"] is only a list if there's\n # more than one comment...\n comments = sub_file[\"comment\"]\n if isinstance(comments, list):\n # Could be: \"Derived ArrayExpress Data Matrix FTP\n # file\" or: \"ArrayExpress FTP file\". If there is\n # no comment with a name including \"FTP file\" then\n # we don't know where to download it so we need to\n # mark this job as an error. Therefore don't catch\n # the potential exception where download_url\n # doesn't get defined.\n for comment in comments:\n if \"FTP file\" in comment[\"name\"]:\n download_url = comment[\"value\"]\n break\n else:\n download_url = comments[\"value\"]\n\n if not download_url:\n logger.error(\n \"Sample %s did not specify a download url, skipping.\",\n sample_accession_code,\n experiment_accession_code=experiment.accession_code,\n survey_job=self.survey_job.id,\n sub_file=sub_file,\n )\n skip_sample = True\n continue\n\n if not filename:\n logger.error(\n \"Sample %s did not specify a filename, skipping.\",\n sample_accession_code,\n experiment_accession_code=experiment.accession_code,\n survey_job=self.survey_job.id,\n sub_file=sub_file,\n )\n skip_sample = True\n continue\n\n if skip_sample:\n continue\n\n # The accession code is not a simple matter to determine.\n sample_source_name = sample_data[\"source\"].get(\"name\", \"\")\n sample_assay_name = sample_data[\"assay\"].get(\"name\", \"\")\n sample_accession_code = self.determine_sample_accession(\n experiment.accession_code,\n sample_source_name,\n sample_assay_name,\n filename,\n )\n\n # Figure out the Organism for this sample\n organism_name = UNKNOWN\n for characteristic in sample_data[\"characteristic\"]:\n if characteristic[\"category\"].upper() == \"ORGANISM\":\n organism_name = characteristic[\"value\"].upper()\n\n if organism_name == UNKNOWN:\n logger.error(\n \"Sample %s did not specify the organism name.\",\n sample_accession_code,\n experiment_accession_code=experiment.accession_code,\n survey_job=self.survey_job.id,\n )\n organism = None\n continue\n else:\n organism = Organism.get_object_for_name(organism_name)\n\n # Create the sample object\n try:\n # Associate it with the experiment, but since it\n # already exists it already has original files\n # associated with it and it's already been downloaded,\n # so don't add it to created_samples.\n sample_object = Sample.objects.get(accession_code=sample_accession_code)\n\n # If input experiment includes new protocol information,\n # update sample's protocol_info.\n existing_protocols = sample_object.protocol_info\n protocol_info, is_updated = self.update_sample_protocol_info(\n existing_protocols,\n experiment.protocol_description,\n experiment.source_url + \"/protocols\",\n )\n if is_updated:\n sample_object.protocol_info = protocol_info\n sample_object.save()\n\n logger.debug(\n \"Sample %s already exists, skipping object creation.\",\n sample_accession_code,\n experiment_accession_code=experiment.accession_code,\n survey_job=self.survey_job.id,\n )\n except Sample.DoesNotExist:\n sample_object = Sample()\n\n # The basics\n sample_object.source_database = \"ARRAY_EXPRESS\"\n sample_object.title = title\n sample_object.accession_code = sample_accession_code\n sample_object.source_archive_url = samples_endpoint\n sample_object.organism = organism\n sample_object.platform_name = platform_dict[\"platform_accession_name\"]\n sample_object.platform_accession_code = platform_dict[\"platform_accession_code\"]\n sample_object.manufacturer = platform_dict[\"manufacturer\"]\n sample_object.technology = \"MICROARRAY\"\n\n protocol_info, is_updated = self.update_sample_protocol_info(\n existing_protocols=[],\n experiment_protocol=experiment.protocol_description,\n protocol_url=experiment.source_url + \"/protocols\",\n )\n # Do not check is_updated the first time because we must\n # save a list so we can append to it later.\n sample_object.protocol_info = protocol_info\n\n sample_object.save()\n\n # Directly assign the harmonized properties\n harmonized_sample = harmonized_samples[title]\n ArrayExpressSurveyor._apply_harmonized_metadata_to_sample(\n sample_object, harmonized_sample\n )\n\n sample_annotation = SampleAnnotation()\n sample_annotation.name = \"raw_metadata\"\n sample_annotation.data = sample_data\n sample_annotation.sample = sample_object\n sample_annotation.is_ccdl = False\n sample_annotation.save()\n\n original_file = OriginalFile()\n original_file.filename = filename\n original_file.source_filename = filename\n original_file.source_url = download_url\n original_file.is_downloaded = False\n original_file.is_archive = True\n original_file.has_raw = has_raw\n original_file.save()\n\n original_file_sample_association = OriginalFileSampleAssociation()\n original_file_sample_association.original_file = original_file\n original_file_sample_association.sample = sample_object\n original_file_sample_association.save()\n\n created_samples.append(sample_object)\n\n logger.debug(\n \"Created \" + str(sample_object),\n experiment_accession_code=experiment.accession_code,\n survey_job=self.survey_job.id,\n sample=sample_object.id,\n )\n\n # Create associations if they don't already exist\n ExperimentSampleAssociation.objects.get_or_create(\n experiment=experiment, sample=sample_object\n )\n\n ExperimentOrganismAssociation.objects.get_or_create(\n experiment=experiment, organism=organism\n )\n\n return created_samples","def divide_data(n_reconstructions, ratio = [.8,.1,.1], test_set = True, random = False):\r\n\r\n\tassert np.sum(ratio) == 1.\r\n\r\n\tif test_set:\r\n\t\tassert len(ratio) == 3\r\n\r\n\telse:\r\n\t\tassert len(ratio) == 2\r\n\t\t\t\r\n\tif random:\r\n\t\tnp.random.seed(0)\r\n\r\n\t\tr = np.arange(n_reconstructions)\r\n\t\tnp.random.shuffle(r)\r\n\r\n\t\ti_train = r[:int(ratio[0]*n_reconstructions)]\r\n\t\ti_valid = r[int(ratio[0]*n_reconstructions):int((ratio[0]+ratio[1])*n_reconstructions)]\r\n\r\n\t\tif test_set:\r\n\t\t\ti_test = r[int((ratio[0]+ratio[1])*n_reconstructions):]\r\n\r\n\telse :\r\n\t\tr = np.arange(n_reconstructions)\r\n\t\ti_valid = r[(r+1) % int(ratio[1]*100) == 0]\r\n\r\n\t\tif test_set:\r\n\t\t\ti_test = r[(r+2) % int(ratio[2]*100) == 0]\r\n\t\t\ti_train = r[((r+1) % int(ratio[1]*100) != 0)*((r+2) % int(ratio[2]*100) != 0)]\r\n\t\t\r\n\t\telse:\r\n\t\t\ti_train = r[(r+1) % int(ratio[1]*100) != 0]\r\n\r\n\tif not(test_set):\r\n\t\ti_test = []\r\n\r\n\treturn i_train,i_valid,i_test","def test_documentation_popxl_create_multi_subgraph(self):\n filename = \"create_multi_graphs_from_same_func.py\"\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)","def create_materials(endpoint):\n for phenotype in get_phenotypes(endpoint):\n print(phenotype)\n # for now, creating the sample name combining studyDbId and potDbId -\n # eventually this should be observationUnitDbId\n sample_name = phenotype['studyDbId']+\"_\"+phenotype['plotNumber']\n this_sample = Sample(name=sample_name)\n that_source = Source(phenotype['germplasmName'], phenotype['germplasmDbId'])\n this_sample.derives_from = that_source","def make(self):\n numberOfGroups = np.random.randint(1, len(self.getFirstParent().getGroups()))\n secParentGroups = np.random.choice(self.secondParent.getGroups(), numberOfGroups, replace=False)\n groups = []\n allSecElements = []\n numberOfElements = 0\n\n for grpSec in secParentGroups:\n allSecElements += grpSec.getElements()\n\n for grpFst in self.getFirstParent().getGroups():\n numberOfElements += len(grpFst.getElements())\n elements = list(set(grpFst.getElements()) - set(allSecElements))\n group = Group(grpFst.getIndex(), grpFst.getMinElements(), grpFst.getMaxElements())\n group.setElements(elements)\n groups.append(group)\n\n for grpSec in secParentGroups:\n for grpFst in groups:\n if grpSec.getIndex() == grpFst.getIndex():\n grpFst.addElements(grpSec.getElements())\n\n child = Individual(np.zeros(numberOfElements))\n child.setGroups(groups)\n\n return child","def three_experiments_with_trials(family_with_trials, single_with_trials):","def disaggregate_chunk(self, test_mains):\n raise NotImplementedError()","def regular_subsample(neuron):\n # select all the main points\n selected_index = get_main_points(neuorn)\n\n # Computing the parent id of the selected nodes\n neuron = neuron_with_selected_nodes(selected_index)\n return neuron","def __init__(self, pattern_type, experimental_scenario, pattern):\n self.pattern_type = pattern_type # if pattern_type=1 --> experimental group, otherwise control group\n self.experimental_scenario = experimental_scenario\n self.pattern = pattern","def testA_FileSplitting(self):\n splitter = SplitterFactory()\n\n oneSetSubscription = self.createSubscription(nFiles=10, lumisPerFile=1)\n jobFactory = splitter(package=\"WMCore.WMBS\", subscription=oneSetSubscription)\n\n jobGroups = jobFactory(lumis_per_job=3, halt_job_on_file_boundaries=True, performance=self.performanceParams)\n self.assertEqual(len(jobGroups), 1)\n self.assertEqual(len(jobGroups[0].jobs), 10)\n for job in jobGroups[0].jobs:\n self.assertTrue(len(job['input_files']), 1)\n self.assertEqual(job['estimatedJobTime'], 100 * 12)\n self.assertEqual(job['estimatedDiskUsage'], 100 * 400)\n self.assertEqual(job['estimatedMemoryUsage'], 2300)\n\n twoLumiFiles = self.createSubscription(nFiles=5, lumisPerFile=2)\n jobFactory = splitter(package=\"WMCore.WMBS\", subscription=twoLumiFiles)\n jobGroups = jobFactory(lumis_per_job=1, halt_job_on_file_boundaries=True, performance=self.performanceParams)\n self.assertEqual(len(jobGroups), 1)\n self.assertEqual(len(jobGroups[0].jobs), 10)\n for job in jobGroups[0].jobs:\n self.assertEqual(len(job['input_files']), 1)\n self.assertEqual(job['estimatedJobTime'], 50 * 12)\n self.assertEqual(job['estimatedDiskUsage'], 50 * 400)\n self.assertEqual(job['estimatedMemoryUsage'], 2300)\n\n wholeLumiFiles = self.createSubscription(nFiles=5, lumisPerFile=3)\n jobFactory = splitter(package=\"WMCore.WMBS\", subscription=wholeLumiFiles)\n jobGroups = jobFactory(lumis_per_job=2, halt_job_on_file_boundaries=True, performance=self.performanceParams)\n self.assertEqual(len(jobGroups), 1)\n # 10 because we split on run boundaries\n self.assertEqual(len(jobGroups[0].jobs), 10)\n jobList = jobGroups[0].jobs\n for idx, job in enumerate(jobList, start=1):\n # Have should have one file, half two\n self.assertEqual(len(job['input_files']), 1)\n if idx % 2 == 0:\n self.assertEqual(job['estimatedJobTime'], (1.0 * round(100 / 3)) * 12)\n self.assertEqual(job['estimatedDiskUsage'], (1.0 * round(100 / 3)) * 400)\n else:\n self.assertEqual(job['estimatedJobTime'], (2.0 * round(100 / 3)) * 12)\n self.assertEqual(job['estimatedDiskUsage'], (2.0 * round(100 / 3)) * 400)\n self.assertEqual(job['estimatedMemoryUsage'], 2300)\n\n mask0 = jobList[0]['mask'].getRunAndLumis()\n self.assertEqual(mask0, {0: [[0, 1]]})\n mask1 = jobList[1]['mask'].getRunAndLumis()\n self.assertEqual(mask1, {0: [[2, 2]]})\n mask2 = jobList[2]['mask'].getRunAndLumis()\n self.assertEqual(mask2, {1: [[100, 101]]})\n mask3 = jobList[3]['mask'].getRunAndLumis()\n self.assertEqual(mask3, {1: [[102, 102]]})\n\n j0 = Job(id=jobList[0]['id'])\n j0.loadData()\n self.assertEqual(j0['mask'].getRunAndLumis(), {0: [[0, 1]]})\n\n # Do it with multiple sites\n twoSiteSubscription = self.createSubscription(nFiles=5, lumisPerFile=2, twoSites=True)\n jobFactory = splitter(package=\"WMCore.WMBS\",\n subscription=twoSiteSubscription)\n jobGroups = jobFactory(lumis_per_job=1,\n halt_job_on_file_boundaries=True,\n performance=self.performanceParams)\n self.assertEqual(len(jobGroups), 2)\n self.assertEqual(len(jobGroups[0].jobs), 10)\n for job in jobGroups[0].jobs:\n self.assertEqual(len(job['input_files']), 1)\n self.assertEqual(job['estimatedJobTime'], 50 * 12)\n self.assertEqual(job['estimatedDiskUsage'], 50 * 400)\n self.assertEqual(job['estimatedMemoryUsage'], 2300)","def make_sub(self, sub):\n [lu, subs] = [self.lineup, self.subs]\n if 'PositionSwitch' in str(type(sub)):\n done = False\n for player in lu:\n if player.id == sub.player:\n done = True\n player.switch.append(player.pos)\n player.pos = sub.pos\n if sub.pos in player.switch:\n player.switch.remove(sub.pos)\n if not done:\n sub_idx = find_player_index(subs, sub.player)\n if sub.pos == 'p':\n subs[sub_idx].status = 'entered'\n if not len([s for s in lu if s.pos == 'p']) > 0:\n subs[sub_idx].order = 10\n lu.append(subs.pop(sub_idx))\n else:\n print(\"ERROR: NOT SURE WHAT TO DO WITH SUB\")\n print([p.__dict__ for p in lu])\n print(sub.__dict__)\n\n elif 'OffensiveSub' in str(type(sub)):\n lu_idx = find_player_index(lu, sub.sub)\n sub_idx = find_player_index(subs, sub.player)\n if sub_idx is None:\n print(\"ERROR: \" + str(sub.__dict__))\n else:\n if subs[sub_idx].status == 'removed':\n print('ILLEGAL SUB ' + str(subs[sub_idx].__dict__))\n if not lu_idx is None:\n lu[lu_idx].status = 'removed'\n subs.append(lu.pop(lu_idx))\n lu.insert(lu_idx, subs.pop(sub_idx))\n\n elif 'DefensiveSub' in str(type(sub)):\n lu_idx = find_player_index(lu, sub.sub)\n sub_idx = find_player_index(subs, sub.player)\n if sub_idx is None:\n if sub.pos == 'p':\n sub_idx = find_player_index(lu, sub.player)\n if not sub_idx is None and not lu_idx is None:\n add = lu[sub_idx]\n lu[lu_idx].status = 'removed'\n subs.append(lu.pop(lu_idx))\n lu.insert(lu_idx, add)\n if lu[lu_idx].order == 10:\n lu[lu_idx].order = lu_idx+1\n else:\n print(\"ERROR: \" + str(sub.__dict__))\n else:\n if subs[sub_idx].status == 'removed':\n print('ILLEGAL SUB ' + str(subs[sub_idx].__dict__ ))\n if not lu_idx is None: \n lu[lu_idx].status = 'removed'\n if lu[lu_idx].order != subs[sub_idx].order:\n print(\"ASSUMING ORDER FOR SUB: \" + subs[sub_idx].name)\n subs[sub_idx].order = lu[lu_idx].order\n for p in lu:\n if p.pos == subs[sub_idx].pos:\n p.pos = ''\n subs.append(lu.pop(lu_idx))\n lu.insert(lu_idx, subs.pop(sub_idx))\n\n elif 'Removal' in str(type(sub)):\n if lu[-1].id == sub.sub:\n lu_idx = len(lu)-1\n else:\n lu_idx = find_player_index(lu, sub.sub)\n if not lu_idx is None:\n lu[lu_idx].status = 'removed'\n subs.append(lu.pop(lu_idx))\n \n\n [self.lineup, self.subs] = [lu, subs]","def __init__(self, specprod_dir=None, **kwargs):\n if specprod_dir is None:\n specprod_dir = specprod_root()\n self.specprod_dir = specprod_dir\n # Init\n QA_MultiExp.__init__(self, specprod_dir=specprod_dir, **kwargs)\n # Load up exposures for the full production\n nights = get_nights(specprod_dir=self.specprod_dir)\n for night in nights:\n self.mexp_dict[night] = {}\n for exposure in get_exposures(night, specprod_dir = self.specprod_dir):\n # Object only??\n frames_dict = get_files(filetype = str('frame'), night = night,\n expid = exposure, specprod_dir = self.specprod_dir)\n self.mexp_dict[night][exposure] = frames_dict\n # Output file names\n self.qaexp_outroot = self.qaprod_dir+'/'+self.prod_name+'_qa'\n # Nights list\n self.qa_nights = []","def _trainSubdomainROMs(self, templateROM, counter, trainingSet, romGlobalAdjustments):\n targets = templateROM.target[:]\n # clear indices from teh training list, since they're independents\n # TODO assumes pivotParameter is the only subspace being divided\n pivotID = templateROM.pivotParameterID\n targets.remove(pivotID)\n # stash pivot values, since those will break up while training segments\n # TODO assumes only pivot param\n if pivotID not in self._indexValues:\n self._indexValues[pivotID] = trainingSet[pivotID][0]\n # loop over clusters and train data\n roms = []\n for i, subdiv in enumerate(counter):\n # slicer for data selection\n picker = slice(subdiv[0], subdiv[-1] + 1)\n ## TODO we need to be slicing all the data, not just one realization, once we support non-ARMA segmentation.\n data = dict((var, [copy.deepcopy(trainingSet[var][0][picker])]) for var in trainingSet)\n # renormalize the pivot if requested, e.g. by shifting values\n norm = self._divisionPivotShift[pivotID]\n if norm:\n if norm == 'zero':\n # left-shift pivot so subspace starts at 0 each time\n delta = data[pivotID][0][0]\n elif norm == 'first':\n # left-shift so that first entry is equal to pivot's first value (maybe not zero)\n delta = data[pivotID][0][0] - trainingSet[pivotID][0][0]\n data[pivotID][0] -= delta\n # create a new ROM and train it!\n newROM = copy.deepcopy(templateROM)\n newROM.name = '{}_seg{}'.format(self._romName, i)\n newROM.adjustLocalRomSegment(self._romGlobalAdjustments)\n self.raiseADebug('Training segment', i, picker)\n newROM.train(data)\n roms.append(newROM)\n # format array for future use\n roms = np.array(roms)\n return roms","def split(complex, ligand_res_name='LIG'):\n\n # Set empty molecule containers\n prot = oechem.OEMol()\n lig = oechem.OEMol()\n wat = oechem.OEMol()\n other = oechem.OEMol()\n\n # Define the Filter options before the splitting\n opt = oechem.OESplitMolComplexOptions()\n\n # The protein filter is set to avoid that multiple\n # chains are separated during the splitting and peptide\n # molecules are recognized as ligands\n pf = oechem.OEMolComplexFilterFactory(oechem.OEMolComplexFilterCategory_Protein) \n peptide = oechem.OEMolComplexFilterFactory(oechem.OEMolComplexFilterCategory_Peptide)\n protein_filter = oechem.OEOrRoleSet(pf, peptide)\n opt.SetProteinFilter(protein_filter)\n \n # The ligand filter is set to recognize just the ligand\n lf = oechem.OEMolComplexFilterFactory(oechem.OEMolComplexFilterCategory_Ligand)\n not_protein_filter = oechem.OENotRoleSet(protein_filter)\n ligand_filter = oechem.OEAndRoleSet(lf, not_protein_filter)\n opt.SetLigandFilter(ligand_filter)\n\n # The water filter is set to recognize just water molecules\n wf = oechem.OEMolComplexFilterFactory(oechem.OEMolComplexFilterCategory_Water)\n opt.SetWaterFilter(wf)\n\n # Set Category\n cat = oechem.OEMolComplexCategorizer()\n cat.AddLigandName(ligand_res_name)\n opt.SetCategorizer(cat)\n\n # Splitting the system\n if not oechem.OESplitMolComplex(lig, prot, wat, other, complex, opt):\n raise ValueError('Unable to split the complex')\n \n # At this point prot contains the protein, lig contains the ligand,\n # wat contains the water and excipients contains the excipients\n\n return prot, lig, wat, other","def generate_test_instances(self):\n for testproblem in self.testproblems:\n for solverconfig in self.solverconfigs:\n self.instances.append(TestInstance(testproblem, solverconfig))","def __init__(self,subWindow,currentExperiment):\n super(AmoebaCreateExperiment,self).__init__()\n self.stage = 0\n self.currentExperiment = currentExperiment\n #self.XMLWriter = ExperimentXMLWriter()\n self.XMLWriter = Amoeba_experiment()\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\n print \"Create new experiment.\"\n\n self.subWindow = subWindow\n\n #Create a scroll bar for the summary area\n self.layout = QVBoxLayout()\n\n #Create the widgets\n self.SetFundamentalParameters = AmoebaSetFundamentalParameters()\n self.ShowAllInstruments = AmoebaShowAllInstuments()\n self.LinkInstruments = LinkInstrumentsForm()\n\n self.next = QPushButton(\"Next\")\n self.next.clicked.connect(self.next_pressed)\n\n #Add to the scroll widget\n self.layout.addWidget(self.SetFundamentalParameters)\n self.layout.addWidget(self.ShowAllInstruments)\n self.layout.addWidget(self.LinkInstruments)\n self.layout.addWidget(self.next)\n\n #Add the Widgets to the Subwindow\n self.setLayout(self.layout)\n\n #Hide all the widgets that will later be revealed.\n self.SetFundamentalParameters.hide()\n self.LinkInstruments.hide()","def test_construct_subcircuit_layers(self):\r\n dev = qml.device(\"default.qubit\", wires=3)\r\n\r\n def circuit(params):\r\n # section 1\r\n qml.RX(params[0], wires=0)\r\n # section 2\r\n qml.RY(params[1], wires=0)\r\n qml.CNOT(wires=[0, 1])\r\n qml.CNOT(wires=[1, 2])\r\n # section 3\r\n qml.RX(params[2], wires=0)\r\n qml.RY(params[3], wires=1)\r\n qml.RZ(params[4], wires=2)\r\n qml.CNOT(wires=[0, 1])\r\n qml.CNOT(wires=[1, 2])\r\n # section 4\r\n qml.RX(params[5], wires=0)\r\n qml.RY(params[6], wires=1)\r\n qml.RZ(params[7], wires=2)\r\n qml.CNOT(wires=[0, 1])\r\n qml.CNOT(wires=[1, 2])\r\n return qml.expval(qml.PauliX(0)), qml.expval(qml.PauliX(1)), qml.expval(qml.PauliX(2))\r\n\r\n circuit = qml.QNode(circuit, dev)\r\n\r\n params = np.ones([8])\r\n tapes = circuit.metric_tensor(params, only_construct=True)\r\n\r\n # this circuit should split into 4 independent\r\n # sections or layers when constructing subcircuits\r\n assert len(tapes) == 4\r\n\r\n # first layer subcircuit\r\n assert len(tapes[0].operations) == 1\r\n assert isinstance(tapes[0].operations[0], qml.Hadamard) # PauliX decomp\r\n\r\n # second layer subcircuit\r\n assert len(tapes[1].operations) == 4\r\n assert isinstance(tapes[1].operations[0], qml.RX)\r\n # PauliY decomp\r\n assert isinstance(tapes[1].operations[1], qml.PauliZ)\r\n assert isinstance(tapes[1].operations[2], qml.S)\r\n assert isinstance(tapes[1].operations[3], qml.Hadamard)\r\n\r\n # # third layer subcircuit\r\n assert len(tapes[2].operations) == 8\r\n assert isinstance(tapes[2].operations[0], qml.RX)\r\n assert isinstance(tapes[2].operations[1], qml.RY)\r\n assert isinstance(tapes[2].operations[2], qml.CNOT)\r\n assert isinstance(tapes[2].operations[3], qml.CNOT)\r\n # PauliX decomp\r\n assert isinstance(tapes[2].operations[4], qml.Hadamard)\r\n # PauliY decomp\r\n assert isinstance(tapes[2].operations[5], qml.PauliZ)\r\n assert isinstance(tapes[2].operations[6], qml.S)\r\n assert isinstance(tapes[2].operations[7], qml.Hadamard)\r\n\r\n # # fourth layer subcircuit\r\n assert len(tapes[3].operations) == 13\r\n assert isinstance(tapes[3].operations[0], qml.RX)\r\n assert isinstance(tapes[3].operations[1], qml.RY)\r\n assert isinstance(tapes[3].operations[2], qml.CNOT)\r\n assert isinstance(tapes[3].operations[3], qml.CNOT)\r\n assert isinstance(tapes[3].operations[4], qml.RX)\r\n assert isinstance(tapes[3].operations[5], qml.RY)\r\n assert isinstance(tapes[3].operations[6], qml.RZ)\r\n assert isinstance(tapes[3].operations[7], qml.CNOT)\r\n assert isinstance(tapes[3].operations[8], qml.CNOT)\r\n # PauliX decomp\r\n assert isinstance(tapes[3].operations[9], qml.Hadamard)\r\n # PauliY decomp\r\n assert isinstance(tapes[3].operations[10], qml.PauliZ)\r\n assert isinstance(tapes[3].operations[11], qml.S)\r\n assert isinstance(tapes[3].operations[12], qml.Hadamard)","def _exp_splayer(ss) :\n\texp_list = ss.experiments\n\tfor exp in exp_list : \n\t\tss_copy = copy.copy(ss) # create a copy of original ss\n\t\tss_copy.experiments = [exp]\n\t\tyield ss_copy","def exp_main(self, use_remote_data=True, test=False):\n test = str_to_bool(test)\n use_remote_data = str_to_bool(use_remote_data)\n root_uri = get_root_uri(use_remote_data)\n root_uri = os.path.join(root_uri, rv_output_dir)\n spacenet_config = VegasBuildings(use_remote_data)\n experiments = []\n runs = [0]\n\n noise_modes = [\n NoiseMode(NoiseMode.SHIFT, 0),\n NoiseMode(NoiseMode.SHIFT, 10),\n NoiseMode(NoiseMode.SHIFT, 20),\n NoiseMode(NoiseMode.SHIFT, 30),\n NoiseMode(NoiseMode.SHIFT, 40),\n NoiseMode(NoiseMode.SHIFT, 50),\n NoiseMode(NoiseMode.DROP, 0.0),\n NoiseMode(NoiseMode.DROP, 0.1),\n NoiseMode(NoiseMode.DROP, 0.2),\n NoiseMode(NoiseMode.DROP, 0.3),\n NoiseMode(NoiseMode.DROP, 0.4),\n NoiseMode(NoiseMode.DROP, 0.5)\n ]\n\n for nm in noise_modes:\n for run in runs:\n exp_id = get_exp_id(nm, run)\n task = build_task(spacenet_config.get_class_map())\n backend = build_fastai_backend(task, test)\n analyzer = rv.AnalyzerConfig.builder(rv.STATS_ANALYZER) \\\n .build()\n dataset = build_dataset(task, spacenet_config, test, nm)\n\n experiment = rv.ExperimentConfig.builder() \\\n .with_id(exp_id) \\\n .with_analyze_key('shift-0-0') \\\n .with_task(task) \\\n .with_backend(backend) \\\n .with_analyzer(analyzer) \\\n .with_dataset(dataset) \\\n .with_root_uri(root_uri) \\\n .build()\n experiments.append(experiment)\n\n return experiments","def subdivide(self, subdivision, new_point):\n\n\t\tassert(subdivision.ndim == 3)\n\n\t\t# Find the attached faces.\n\t\tface1, face2, face3, face4 = self.attached_faces\n\n\t\t# Find the attached lines, and be able to associate them with the\n\t\t# faces.\n\t\tline12, = face1.attached_lines & face2.attached_lines\n\t\tline13, = face1.attached_lines & face3.attached_lines\n\t\tline14, = face1.attached_lines & face4.attached_lines\n\t\tline23, = face2.attached_lines & face3.attached_lines\n\t\tline24, = face2.attached_lines & face4.attached_lines\n\t\tline34, = face3.attached_lines & face4.attached_lines\n\n\t\t# Find the attached points, and be able to associate them with the \n\t\t# faces.\n\t\tpoint123, = line12.attached_points & line13.attached_points\n\t\tpoint124, = line12.attached_points & line14.attached_points\n\t\tpoint134, = line13.attached_points & line14.attached_points\n\t\tpoint234, = line23.attached_points & line24.attached_points\n\n\t\t# Create the new lines.\n\t\tnew_line123 = matplot3dext.objects.line.Line(point123, new_point)\n\t\tnew_line124 = matplot3dext.objects.line.Line(point124, new_point)\n\t\tnew_line134 = matplot3dext.objects.line.Line(point134, new_point)\n\t\tnew_line234 = matplot3dext.objects.line.Line(point234, new_point)\n\n\t\t# Create the new faces.\n\t\tnew_face12 = matplot3dext.objects.face.Face(\n\t\t\t\tline12, new_line123, new_line124)\n\t\tnew_face13 = matplot3dext.objects.face.Face(\n\t\t\t\tline13, new_line123, new_line134)\n\t\tnew_face14 = matplot3dext.objects.face.Face(\n\t\t\t\tline14, new_line124, new_line134)\n\t\tnew_face23 = matplot3dext.objects.face.Face(\n\t\t\t\tline23, new_line123, new_line234)\n\t\tnew_face24 = matplot3dext.objects.face.Face(\n\t\t\t\tline24, new_line124, new_line234)\n\t\tnew_face34 = matplot3dext.objects.face.Face(\n\t\t\t\tline34, new_line134, new_line234)\n\n\t\t# Create the new tetrahedra.\n\t\t#\n\t\t# Make a sketch to understand what's going on now.\n\t\tnew_tetrahedron1 = Tetrahedron(\n\t\t\t\tface1, new_face12, new_face13, new_face14)\n\t\tnew_tetrahedron2 = Tetrahedron(\n\t\t\t\tface2, new_face12, new_face23, new_face24)\n\t\tnew_tetrahedron3 = Tetrahedron(\n\t\t\t\tface3, new_face13, new_face23, new_face34)\n\t\tnew_tetrahedron4 = TetrahedroN(\n\t\t\t\tface4, new_face14, new_face24, new_face34)\n\n\t\tself.replace_by([new_tetrahdron1, new_tetrahedron2, \n\t\t\t\tnew_tetrahedron3, new_tetrahedron4], subdivision.world)\n\n\t\treturn new_point","def split(self):\n\n ratio_c = 1 - self.ratio\n self.train, self.test = self.df.randomSplit([self.ratio, ratio_c], seed=12345)","def _generate_examples(self, folders, split):\n raise NotImplementedError(\"TODO\")","def test_split_trajectories():\n\n num_trajectories = 100\n trajectory_timesteps = 100\n subsequence_length = 10\n\n # Generate trajectories\n trajectories: List[torchfilter.types.TrajectoryNumpy] = []\n for i in range(num_trajectories):\n trajectories.append(\n torchfilter.types.TrajectoryNumpy(\n states=np.ones((trajectory_timesteps, 5)),\n observations={\n \"key\": np.zeros((trajectory_timesteps, 5)),\n \"some_other_key\": np.zeros((trajectory_timesteps, 5)),\n },\n controls=np.zeros((trajectory_timesteps, 5)),\n )\n )\n\n # Split into subsequences\n subsequences = torchfilter.data.split_trajectories(\n trajectories, subsequence_length=subsequence_length\n )\n\n # Validate subsequences\n assert len(subsequences) == num_trajectories * 19\n for traj in subsequences:\n assert traj.states.shape == (subsequence_length, 5)\n assert traj.controls.shape == (subsequence_length, 5)\n assert np.allclose(traj.states, 1.0)\n assert \"key\" in traj.observations\n assert \"some_other_key\" in traj.observations\n assert np.allclose(traj.controls, 0.0)","def build_subsets(self):\n self.all = nrn.SectionList()\n self.all.wholetree(sec=self.soma)","def testGetFromSplits(self):\n artifacts = [standard_artifacts.Examples()]\n artifacts[0].uri = '/tmp'\n artifacts[0].split_names = artifact_utils.encode_split_names(\n ['train', 'eval'])\n\n self.assertEqual(artifacts[0].split_names, '[\"train\", \"eval\"]')\n\n self.assertIs(artifact_utils.get_single_instance(artifacts), artifacts[0])\n self.assertEqual('/tmp', artifact_utils.get_single_uri(artifacts))\n self.assertEqual('/tmp/train',\n artifact_utils.get_split_uri(artifacts, 'train'))\n self.assertEqual('/tmp/eval',\n artifact_utils.get_split_uri(artifacts, 'eval'))","def create_subset_list(self):\n\n row = 0\n for time_step in self.min_increments:\n subset = SubsetClass(time_step=time_step, query_df=self.query_df, model_df=self.model_df, row=row)\n self.subset_list.append(subset)\n row += 1","def split_data(self, verbose=False):\n # group sample by patient and body part\n tmp = self.data_info.groupby(['patientID', 'body_part']).max()\n # get the index (i.e. patient and bodypart) where none of the body part XR of a given patient are abnormal\n idx_list_normal = tmp[tmp.body_part_abnormal == 0].index.to_list()\n # get the index (i.e. patient and bodypart) where at least one but not all of the body part XR of a given patient are abnormal\n idx_list_mixt = tmp[tmp.body_part_abnormal == 0.5].index.to_list()\n # get the index (i.e. patient and bodypart) where all one of the body part XR of a given patient are abnormal\n idx_list_abnormal = tmp[tmp.body_part_abnormal == 1].index.to_list()\n total = len(idx_list_normal)+len(idx_list_mixt)+len(idx_list_abnormal)\n train_size = self.train_frac*total\n assert train_size < len(idx_list_normal), f'There are not enough normal sample for the given train_frac : {self.train_frac}. \\\n There are {len(idx_list_normal)} normal sample over {total} total samples.'\n valid_size = (1-self.train_frac)*0.5*total\n test_size = (1-self.train_frac)*0.5*total\n # randomly pick (1-ratio_known_abnormal)*train_frac*total from the normal index for the train set\n train_idx_normal, remain = train_test_split(idx_list_normal, \\\n train_size=int((1-self.ratio_known_abnormal)*train_size),\\\n random_state=self.random_state)\n # split the rest equally in the validation and test set\n valid_idx_normal, test_idx_normal = train_test_split(remain, test_size=0.5, random_state=self.random_state)\n # add ratio_known_abnormal*train_frac*total from the abnormal index\n if self.ratio_known_abnormal == 0.0:\n train_idx_abnormal, remain = [], idx_list_abnormal\n else:\n train_idx_abnormal, remain = train_test_split(idx_list_abnormal, \\\n train_size=int(self.ratio_known_abnormal*train_size),\\\n random_state=self.random_state)\n # split the rest equally in the validation and test set\n valid_idx_abnormal, test_idx_abnormal = train_test_split(remain, test_size=0.5, random_state=self.random_state)\n # split the mixt between test and validation and consider them as abnormal patients bodypart\n valid_idx_mixt, test_idx_mixt = train_test_split(idx_list_mixt, test_size=0.5, random_state=self.random_state)\n valid_idx_abnormal += valid_idx_mixt\n test_idx_abnormal += test_idx_mixt\n # get the known and unknown index for each sets\n # get a fraction of normal known\n if self.ratio_known_normal == 0.0:\n train_idx_known, train_idx_unknown = [], train_idx_normal\n valid_idx_known, valid_idx_unknown = [], valid_idx_normal\n test_idx_known, test_idx_unknown = [], test_idx_normal\n else:\n train_idx_known, train_idx_unknown = train_test_split(train_idx_normal, \\\n train_size=int(self.ratio_known_normal*train_size),\\\n random_state=self.random_state)\n valid_idx_known, valid_idx_unknown = train_test_split(valid_idx_normal, \\\n train_size=int(self.ratio_known_normal*valid_size),\\\n random_state=self.random_state)\n test_idx_known, test_idx_unknown = train_test_split(test_idx_normal, \\\n train_size=int(self.ratio_known_normal*test_size), \\\n random_state=self.random_state)\n # get the abnormal known\n # all abnormal in train are known\n train_idx_known += train_idx_abnormal\n if self.ratio_known_abnormal == 0.0:\n valid_idx_unknown += valid_idx_abnormal\n test_idx_unknown += test_idx_abnormal\n else:\n valid_idx_known_abnormal, valid_idx_unknown_abnormal = train_test_split(valid_idx_abnormal, \\\n train_size=int(self.ratio_known_abnormal*valid_size), \\\n random_state=self.random_state)\n valid_idx_known += valid_idx_known_abnormal\n valid_idx_unknown += valid_idx_unknown_abnormal\n test_idx_known_abnormal, test_idx_unknown_abnormal = train_test_split(test_idx_abnormal, \\\n train_size=int(self.ratio_known_abnormal*test_size),\\\n random_state=self.random_state)\n test_idx_known += test_idx_known_abnormal\n test_idx_unknown += test_idx_unknown_abnormal\n\n # get the subsample dataframe with semi-label\n train_df = self.generate_semisupervized_label(train_idx_known, train_idx_unknown)\n valid_df = self.generate_semisupervized_label(valid_idx_known, valid_idx_unknown)\n test_df = self.generate_semisupervized_label(test_idx_known, test_idx_unknown)\n # shuffle the dataframes\n self.subsets['train'] = train_df.sample(frac=1, random_state=self.random_state).reset_index(drop=True)\n self.subsets['valid'] = valid_df.sample(frac=1, random_state=self.random_state).reset_index(drop=True)\n self.subsets['test'] = test_df.sample(frac=1, random_state=self.random_state).reset_index(drop=True)\n # Print summary\n if verbose:\n self.print_stat()","def test_partially_one(self):\n setups = self.get_setup().decompress([\"dimensions.species_id\"])\n assert isinstance(setups, PlotSetupGroup)\n assert all(isinstance(setup, PlotSetup) for setup in setups)\n assert len(setups) == 2\n res = {\n (\n s.panels.collect_equal(\"dimensions\").variable,\n s.panels.collect_equal(\"dimensions\").species_id,\n s.panels.collect_equal(\"dimensions\").time,\n )\n for s in setups\n }\n sol = {\n ((\"dry_deposition\", \"wet_deposition\"), 1, (1, 2, 3)),\n ((\"dry_deposition\", \"wet_deposition\"), 2, (1, 2, 3)),\n }\n assert res == sol","def set_up_and_parameterise_model_for_experiment(self):\n self.experiment_unique_steps_to_model = {}\n for op_number, op in enumerate(self.experiment.unique_steps):\n new_model = self.model.new_copy()\n new_parameter_values = self.parameter_values.copy()\n\n if op.type != \"current\":\n # Voltage or power control\n # Create a new model where the current density is now a variable\n # To do so, we replace all instances of the current density in the\n # model with a current density variable, which is obtained from the\n # FunctionControl submodel\n # check which kind of external circuit model we need (differential\n # or algebraic)\n if op.type == \"voltage\":\n submodel_class = pybamm.external_circuit.VoltageFunctionControl\n elif op.type == \"power\":\n submodel_class = pybamm.external_circuit.PowerFunctionControl\n\n # Build the new submodel and update the model with it\n submodel = submodel_class(new_model.param, new_model.options)\n variables = new_model.variables\n submodel.variables = submodel.get_fundamental_variables()\n variables.update(submodel.variables)\n submodel.variables.update(submodel.get_coupled_variables(variables))\n variables.update(submodel.variables)\n submodel.set_rhs(variables)\n submodel.set_algebraic(variables)\n submodel.set_initial_conditions(variables)\n new_model.rhs.update(submodel.rhs)\n new_model.algebraic.update(submodel.algebraic)\n new_model.initial_conditions.update(submodel.initial_conditions)\n\n # Set the \"current function\" to be the variable defined in the submodel\n new_parameter_values[\"Current function [A]\"] = submodel.variables[\n \"Current [A]\"\n ]\n self.update_new_model_events(new_model, op)\n # Update parameter values\n self._original_temperature = new_parameter_values[\"Ambient temperature [K]\"]\n experiment_parameter_values = self.get_experiment_parameter_values(\n op, op_number\n )\n new_parameter_values.update(\n experiment_parameter_values, check_already_exists=False\n )\n parameterised_model = new_parameter_values.process_model(\n new_model, inplace=False\n )\n self.experiment_unique_steps_to_model[repr(op)] = parameterised_model\n\n # Set up rest model if experiment has start times\n if self.experiment.initial_start_time:\n new_model = self.model.new_copy()\n # Update parameter values\n new_parameter_values = self.parameter_values.copy()\n self._original_temperature = new_parameter_values[\"Ambient temperature [K]\"]\n new_parameter_values.update(\n {\"Current function [A]\": 0, \"Ambient temperature [K]\": \"[input]\"},\n check_already_exists=False,\n )\n parameterised_model = new_parameter_values.process_model(\n new_model, inplace=False\n )\n self.experiment_unique_steps_to_model[\n \"Rest for padding\"\n ] = parameterised_model","def initialize_substructure_production(self):\n\n self.wet_storage = WetStorage(self.env, float(\"inf\"))\n takt_time = self.config[\"offshore_substation_substructure\"].get(\"takt_time\", 0)\n attach_time = self.config[\"offshore_substation_topside\"].get(\"attach_time\", 24)\n to_assemble = [1] * self.num_substations\n\n self.assembly_line = SubstationAssemblyLine(to_assemble, takt_time, attach_time, self.wet_storage, 1)\n\n self.env.register(self.assembly_line)\n self.assembly_line.start()","def create_master(exp, var, data=None, new_fields=[]):\n\n if isinstance(var, basestring):\n assert data is not None\n data_dict = data\n new_fields.append(var)\n else:\n # see if it's a Var, and access metadata from the associated\n # Experiment\n if data is None:\n data_dict = var.data\n else:\n data_dict = data\n new_fields.append(var.varname)\n new_fields.extend(var.oldvar)\n\n all_case_vals = exp.all_case_vals()\n\n # Post-process the case inspection a bit:\n # 1) Promote any single-value case to a list with one entry\n for i, case_vals in enumerate(all_case_vals):\n if isinstance(case_vals, str):\n all_case_vals[i] = list(case_vals)\n\n # 2) Make sure they're all still in the data dictionary. This is\n # circular but a necessary sanity check\n for case_bits in product(*all_case_vals):\n assert case_bits in data_dict\n\n # Discover the type of the data passed into this method. If\n # it's an xarray type, we'll preserve that. If it's an iris type,\n # then we need to crash for now.\n first_case = next(exp.all_cases())\n\n proto = data_dict[first_case]\n if isinstance(proto, Dataset):\n return _master_dataset(exp, data_dict, new_fields)\n elif isinstance(proto, DataArray):\n return _master_dataarray(exp, data_dict)\n # elif isinstance(proto, Cube):\n # raise NotImplementedError(\"Cube handling not yet implemented\")\n else:\n raise ValueError(\"Data must be an xarray type\")","def read_and_split_sets():\n gen_train_test_sets(\"Data_Sent_Embds/en_sent.pkl\", \"Data_Sent_Embd_Splitted/en_train.pkl\",\n \"Data_Sent_Embd_Splitted/en_test.pkl\")\n gen_train_test_sets(\"Data_Sent_Embds/es_sent.pkl\", \"Data_Sent_Embd_Splitted/es_train.pkl\",\n \"Data_Sent_Embd_Splitted/es_test.pkl\")\n gen_train_test_sets(\"Data_Sent_Embds/pr_sent.pkl\", \"Data_Sent_Embd_Splitted/pr_train.pkl\",\n \"Data_Sent_Embd_Splitted/pr_test.pkl\")","def _CreateSubmodel(unused_path):\n return confusion_matrices.ConfusionMatrices()","def subgroup(self, IDs):\n return Process([getattr(self, i) for i in IDs])","def test_split_activities(self):\n labels = np.ones(3000)\n labels[range(150)] = 2\n X = np.ones((3000,9))\n splittedX, splitted_y = tutorial_pamap2.split_activities(labels,X,[0], borders=50)\n assert splittedX[0].shape == (50, 9)\n assert splittedX[1].shape == (2750, 9)","def experiments(self, key, value):\n experiments = self.get('experiments', [])\n\n name = value.get('e')\n recid = value.get('0')\n record = get_record_ref(recid, 'experiments')\n\n experiments.append({\n 'curated_relation': record is not None,\n 'name': name,\n 'record': record\n })\n\n return experiments","def _select_and_run_experiment(self, i):\n ipick = self.model.pick()\n if ipick in self.model.uu:\n self.workers[i] = (ipick, 'z')\n self.model.tz.append(ipick)\n self.model.b -= self.cz\n self.finish_time[i] += np.random.uniform(self.cz, self.cz * 2)\n else:\n self.workers[i] = (ipick, 'y')\n self.model.ty.append(ipick)\n self.model.b -= self.cy\n self.finish_time[i] += np.random.uniform(self.cy, self.cy * 2)","def __init__(self, subplot_objects):\n self.subplot_objects = subplot_objects","def new_experiment_from_components(self, dataset_params, input_params,\n architecture, model_params,\n train_params=None,\n name='', description=''):\n exp_name = name or ''\n try:\n # find each component by id then create the full JSON\n dataset_params_obj = self.dbclient.find_by_id(\n ConfigRef.DATASET_PARAMS, dataset_params)\n dataset_params_cf = dataset_params_obj[RefAttr.CONFIG]\n\n input_params_obj = self.dbclient.find_by_id(\n ConfigRef.INPUT_PARAMS, input_params)\n input_params_cf = input_params_obj[RefAttr.CONFIG]\n\n architecture_obj = self.dbclient.find_by_id(\n ConfigRef.ARCHITECTURE, architecture)\n architecture_cf = architecture_obj[RefAttr.CONFIG]\n\n model_params_obj = self.dbclient.find_by_id(\n ConfigRef.MODEL_PARAMS, model_params)\n model_params_cf = model_params_obj[RefAttr.CONFIG]\n\n if train_params:\n train_params_obj = self.dbclient.find_by_id(\n ConfigRef.TRAIN_PARAMS, train_params)\n train_params_cf = train_params_obj[RefAttr.CONFIG]\n else:\n train_params_cf = '{ }'\n\n config = self._new_config_from_components(\n dataset_params_cf, input_params_cf, architecture_cf,\n model_params_cf, train_params_cf\n )\n\n if not name:\n exp_name = ' - '.join([\n dataset_params_obj[RefAttr.NAME],\n input_params_obj[RefAttr.NAME],\n architecture_obj[RefAttr.NAME],\n model_params_obj[RefAttr.NAME],\n train_params_obj[RefAttr.NAME] if train_params else '',\n ])\n return self.new_experiment_from_full_config(\n exp_name, config, description=description)\n except Exception:\n return None","def create_data_generators(shuffle=True, novelty_type='normal', item_to_include='None',\n scale_level=1):\n\n total_noi_i = 10 # Number of processed images from one environemnt i\n noe = 1 # Numer of environments\n n_p = 32 # Patch size, patch --> n_p x n_p\n\n novelty = novelty_type\n datasets = []\n\n for i in range(noe):\n\n # Load only images of the environment which includes images of the stated novel item.\n if item_to_include is not None and novelty == 'novel_item':\n dataset_env_i = PolycraftDatasetWithSpecificItem(\n nov_type=novelty, noi=total_noi_i, env_idx=i, p_size=n_p, scale_factor=scale_level,\n item_name=item_to_include)\n datasets.append(dataset_env_i)\n # We only process the one environment with the item (maybe change this\n # if we have more than one environement per novel_item!?)\n break\n\n # No specific item given which should be included.\n else:\n dataset_env_i = PolycraftDatasetNoSpecificItem(\n nov_type=novelty, noi=total_noi_i, env_idx=i, p_size=n_p, scale_factor=scale_level)\n datasets.append(dataset_env_i)\n\n final_dataset = ConcatDataset(datasets)\n\n total_noi = len(final_dataset) # Total number of processed images from all datasets\n\n if(total_noi < 7):\n print('Number of samples too small for splitting dataset in training-/valid-/test set.')\n\n train_noi = int(0.7 * total_noi) # Number of images used for training (70 %)\n valid_noi = int(0.15 * total_noi) # Number of images used for validation (15 %)\n test_noi = total_noi - train_noi - valid_noi # Number of images used for testing (15 %)\n train_dataset, valid_dataset, test_dataset = torch.utils.data.random_split(\n final_dataset, [train_noi, valid_noi, test_noi])\n\n train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True)\n valid_loader = DataLoader(valid_dataset, batch_size=1, shuffle=True)\n test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True)\n\n return train_loader, valid_loader, test_loader","def instantiate(self):\n return _libsbml.Submodel_instantiate(self)","def _create_examples(self, lines: List[str], mode: Split):\n test_mode = mode == Split.test\n q1_index = 1 if test_mode else 3\n q2_index = 2 if test_mode else 4\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (mode.value, line[0])\n try:\n text_a = line[q1_index]\n text_b = line[q2_index]\n label = None if test_mode else line[5]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def splits(cls, exts, fields, path='./data/lang8', root='./data',\n train='train', validation='val', test='test', **kwargs):\n return super(USE, cls).splits(\n path, root, train, validation, test, exts=exts, fields=fields, **kwargs)","def _build_experiment_chiapet_embedded_list():\n antibody_embeds = DependencyEmbedder.embed_defaults_for_type(\n base_path='antibody',\n t='antibody')\n return (\n Experiment.embedded_list + antibody_embeds\n )","def sample_from_subpop(instance, params, subpop):\n y = subpop\n x = np.random.choice([-1,+1], size=params['d'])\n x[instance['indices'][subpop]] = instance['values'][subpop]\n return x, y, subpop","def get_specs(subj_name='mmddyyn_wmLoadMem02'):\n \n dictDlg = gui.DlgFromDict({'Participant number': '07dd19n_eyeSustAttnWM03', #subject name: month, day, year, number, and project name\n 'Environment':['booth','eeg','Dirk VU','imac','edslab'], #which environment (aka monitor name in Tools > Monitor Center)\n 'Restarting experiment?':False, #whether restarting an experiment that was aborted in the middle\n 'Debug':False, #whether instructions are in english\n 'Eye tracker':True,\n 'Picture game':True,\n 'Block game': True},\n title='Welcome to the experiment', #title for GUI\n fixed=[' '],\n order=['Participant number','Environment','Restarting experiment?','Debug','Eye tracker']) #choose order of elements\n if dictDlg.OK == True:\n gui_specs = {}\n gui_specs['subj_name']=str(dictDlg.data[0])\n gui_specs['env'] = dictDlg.data[1]\n gui_specs['restarting'] = dictDlg.data[2]\n gui_specs['expt_date'] = datetime.now().strftime(\"%m/%d/%Y %H:%M\")\n gui_specs['debug'] = dictDlg.data[3]\n gui_specs['eyetrack'] = dictDlg.data[4]\n gui_specs['seed'] = int(time.time())\n gui_specs['sustattn'] = dictDlg.data[5]\n gui_specs['changedetect'] = dictDlg.data[6]\n else:\n core.quit()\n \n #check the specs\n assert isinstance(gui_specs['subj_name'],basestring), \"subj_name is not an string: %r\" % specs['subj_name']\n assert isinstance(gui_specs['env'],basestring), \"env is not a string: %r\" % specs['env']\n assert isinstance(gui_specs['expt_date'],basestring), \"expt_date is not a string: %r\" % specs['expt_date']\n assert isinstance(gui_specs['seed'],int), \"seed is not a int: %r\" % specs['seed']\n\n #which environment is being used to run the experiment\n if gui_specs['env']=='imac':\n gui_specs['project_dir']='/Users/megan/Documents/projects/eyeSustAttnWM03/'\n elif gui_specs['env']=='booth':\n gui_specs['project_dir']='C:/Users/AwhVogelLab/Desktop/Megan/eyeSustAttnWM03/'\n elif gui_specs['env']=='edslab':\n gui_specs['project_dir']='/Users/edslab/Documents/projects/eyeSustAttnWM03/'\n elif gui_specs['env']=='Dirk VU':\n gui_specs['project_dir']='C:/Users/Dirk VU/Documents/Github/eyeSustAttnWM03/'\n elif gui_specs['env']=='eeg':\n gui_specs['project_dir']='C:/Users/awhvogellab/Desktop/Megan/eyeSustAttnWM03/' #FIX THIS LATER\n else:\n pass\n #print 'ERROR: unknown environment selected in the GUI'\n \n #which directory to use to save the data\n gui_specs['save_dir'] = gui_specs['project_dir'] + 'subjects/' + gui_specs['subj_name'] + '/data/beh/'\n \n #if the directory where data will be saved does not exist yet\n if not os.path.isdir(gui_specs['save_dir']):\n #print \"saving files to: \", gui_specs['save_dir']\n os.makedirs(gui_specs['save_dir']) #this command can make multiple subfolders\n \n return gui_specs","def splits(cls, search_query = 'all', max_results = 300, start = 0, reduced_words=1000, savepath='.data', split_ratio=0.7, stratified=False, strata_field='abstract',\n random_state=None, **kwargs):\n\n # initialize text field\n text_field = torchtext.data.Field(tokenize=get_tokenizer(\"spacy\"), init_token='<sos>', eos_token='<eos>', lower=True)\n fields = [('abstract', text_field), ('paper', text_field)]\n examples = []\n\n # Create new dataset by downloading from arxiv or open dataset from folder\n if not os.path.exists(savepath):\n os.mkdir(savepath)\n # create directories for saving the data set\n if not os.path.exists(os.path.join(savepath, 'temp')):\n os.mkdir(os.path.join(savepath, 'temp'))\n if not os.path.exists(os.path.join(savepath, 'abstracts')):\n os.mkdir(os.path.join(savepath, 'abstracts'))\n if not os.path.exists(os.path.join(savepath, 'paper')):\n os.mkdir(os.path.join(savepath, 'paper'))\n data = cls.download(search_query=search_query, max_results=max_results)\n abstracts, papers = cls.extract_paper_and_abstract(data, savepath=savepath)\n\n # generate all examples\n for i, (abstract, paper) in enumerate(zip(abstracts, papers)):\n paper_tokenized = []\n abstract_tokenized = []\n # rdeduce the number of words with the textrank approach\n textranked_paper = summarizer.summarize(paper, words=reduced_words)\n # add start and end token\n paper_tokenized += [u'<sos>'] + text_field.preprocess(textranked_paper) + [u'<eos>']\n abstract_tokenized += [u'<sos>'] + text_field.preprocess(abstract) + [u'<eos>']\n # initialize examples\n examples.append(torchtext.data.Example.fromlist([abstract_tokenized, paper_tokenized], fields))\n\n # save data samples in txt files\n with open(os.path.join(savepath,'abstracts','abstract_' + str(i) + '.txt'), 'w+', encoding='utf-8') as abstr:\n csvwriter = csv.writer(abstr, delimiter=' ')\n csvwriter.writerow(abstract_tokenized)\n with open(os.path.join(savepath,'paper','paper_' + str(i) + '.txt'), 'w+', encoding='utf-8') as pap:\n csvwriter = csv.writer(pap, delimiter=' ')\n csvwriter.writerow(paper_tokenized)\n\n else:\n # read all files in saved data path\n paper_files = os.listdir(os.path.join(savepath,'paper'))\n abstract_files = os.listdir(os.path.join(savepath,'abstracts'))\n data = [[paper, abstract] for paper, abstract in zip(paper_files, abstract_files)]\n papers_tokenized = []\n abstracts_tokenized = []\n # read paper and abstracts from files\n for paper, abstract in data:\n with open(os.path.join(savepath, 'paper', paper), encoding='utf-8') as csvfile:\n paper = csv.reader(csvfile, delimiter=' ')\n for pap in paper:\n if pap:\n papers_tokenized.append(pap)\n with open(os.path.join(savepath, 'abstracts', abstract), encoding='utf-8') as csvfile:\n abstract = csv.reader(csvfile, delimiter=' ')\n for abstr in abstract:\n if abstr:\n abstracts_tokenized.append(abstr)\n \n # generate all examples\n for abstract_tokenized, paper_tokenized in zip(abstracts_tokenized, papers_tokenized):\n examples.append(torchtext.data.Example.fromlist([abstract_tokenized, paper_tokenized], fields))\n\n # create initial dataset\n dataset = PaperAbstractDataset(examples, fields)\n # split dataset\n splits = dataset.split(split_ratio=split_ratio, stratified=stratified, strata_field=strata_field,\n random_state=random_state)\n # initialize vocabulary\n pre_trained_vector_type = 'glove.6B.300d'\n for d in splits:\n for name, field in d.fields.items():\n field.build_vocab(splits[0], vectors=pre_trained_vector_type)\n d.filter_examples(['abstract', 'paper'])\n return splits","def __split_dataset(self):\n self.train, self.valid, _, _ = train_test_split(self.data, self.data, test_size=0.2)\n self.valid, self.test, _, _ = train_test_split(self.valid, self.valid, test_size=0.5)","def _create_examples(self, lines: List[str], mode: Split):\n # id,title,content,label\n test_mode = mode == Split.test\n title_index = 1\n content_index = 2\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (mode.value, line[0])\n try:\n text_a = line[title_index]\n text_b = line[content_index]\n if test_mode:\n label = None\n else:\n label = line[3]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples","def split():\n flag = 0\n for chromosome in region:\n for inf in region[chromosome]:\n if flag == 0:\n if chromosome not in test_set:\n test_set[chromosome] = [inf]\n else:\n test_set[chromosome].append(inf)\n else:\n if chromosome not in train_set:\n train_set[chromosome] = [inf]\n else:\n train_set[chromosome].append(inf)\n\n flag += 1\n flag %= 10","def test_similar_variants_for_varinat_analysis(self):\n self.testcases[0].job_type = 'some_type1'\n self.testcases[0].project_name = 'project1'\n self.testcases[0].crash_state = 'abcde'\n self.testcases[0].one_time_crasher_flag = False\n self.testcases[0].crash_type = 'crash_type1'\n self.testcases[0].security_flag = True\n self.testcases[1].job_type = 'some_type2'\n self.testcases[1].project_name = 'project1'\n self.testcases[1].crash_state = 'vwxyz'\n self.testcases[1].crash_type = 'crash_type2'\n self.testcases[1].one_time_crasher_flag = False\n self.testcases[1].security_flag = True\n\n self.testcases.append(test_utils.create_generic_testcase())\n self.testcases[2].project_name = 'project1'\n self.testcases[2].crash_type = 'a3'\n\n self.testcases.append(test_utils.create_generic_testcase())\n self.testcases[3].project_name = 'project1'\n self.testcases[3].crash_type = 'b4'\n\n self.testcases.append(test_utils.create_generic_testcase())\n self.testcases[4].project_name = 'project1'\n self.testcases[4].crash_type = 'c5'\n\n self.testcases.append(test_utils.create_generic_testcase())\n self.testcases[5].project_name = 'project1'\n self.testcases[5].crash_type = 'd6'\n\n for t in self.testcases:\n t.put()\n\n # testcase2's varinat will be evaluated against testcase1\n self.testcase_variants[0].job_type = 'fake_engine_asan_project1'\n self.testcase_variants[0].testcase_id = self.testcases[0].key.id()\n self.testcase_variants[0].security_flag = True\n self.testcase_variants[1].job_type = 'some_type1'\n self.testcase_variants[1].crash_state = 'abcde'\n self.testcase_variants[1].crash_type = 'crash_type1'\n self.testcase_variants[1].testcase_id = self.testcases[1].key.id()\n self.testcase_variants[1].security_flag = True\n self.testcase_variants.append(test_utils.create_generic_testcase_variant())\n self.testcase_variants.append(test_utils.create_generic_testcase_variant())\n self.testcase_variants.append(test_utils.create_generic_testcase_variant())\n self.testcase_variants.append(test_utils.create_generic_testcase_variant())\n\n for v in self.testcase_variants:\n v.put()\n\n grouper.group_testcases()\n\n for index, t in enumerate(self.testcases):\n self.testcases[index] = data_handler.get_testcase_by_id(t.key.id())\n\n # Check testcases 0 and 1 are grouped together and 0 is the leader.\n self.assertNotEqual(self.testcases[0].group_id, 0)\n self.assertNotEqual(self.testcases[1].group_id, 0)\n self.assertEqual(self.testcases[0].group_id, self.testcases[1].group_id)\n self.assertTrue(self.testcases[0].is_leader)\n self.assertFalse(self.testcases[1].is_leader)\n\n # Check none other testcases are grouped together.\n for i in range(2, 6):\n self.assertEqual(self.testcases[i].group_id, 0)\n self.assertTrue(self.testcases[i].is_leader)","def split_dataset(self, split):\n trunk_pos_size = math.ceil((1 - split) * len(self.Pos))\n trunk_neg_size = math.ceil((1 - split) * len(self.Neg))\n trunk_num = int(1 / (1 - split))\n pos_temp = list()\n neg_temp = list()\n for index in range(trunk_num):\n pos_temp.append(self.Pos[index * trunk_pos_size:(index + 1) *\n trunk_pos_size])\n neg_temp.append(self.Neg[index * trunk_neg_size:(index + 1) *\n trunk_neg_size])\n self.test = pos_temp.pop(2) + neg_temp.pop(2)\n # self.train = [i for item in pos_temp + neg_temp for i in item]\n self.train = []\n for item in pos_temp + neg_temp:\n for i in item:\n self.train.append(i)\n\n random.shuffle(self.train)\n random.shuffle(self.test)","def split_simplified_json_acceptor_dataset(dataset: SimpleJsonAcceptorDataset, split_list):\n import numpy as np\n # create a list of lengths [0.1, 0.4, 0.5] -> [100, 500, 1000(=len_data)]\n split_list = np.multiply(np.cumsum(split_list), len(dataset)).astype(\"int\").tolist()\n # list of shuffled indices to sample randomly\n shuffled_idx = list(range(len(dataset)))\n shuffle(shuffled_idx)\n # split the data itself\n new_data = [[] for _ in range(len(split_list))]\n for sub_data_idx, (start, end) in enumerate(zip([0] + split_list[:-1], split_list)):\n for i in range(start, end):\n new_data[sub_data_idx].append(dataset.__getitem__(shuffled_idx[i]))\n # create sub sets\n sub_datasets = []\n for i in range(len(new_data)):\n ready_dict = {\n \"_idx_to_chr\": dataset._idx_to_chr,\n \"_chr_embed\": dataset._chr_embed,\n \"data\": new_data[i]\n }\n sub_datasets.append(SimpleJsonAcceptorDataset(dataset._size, ready=ready_dict))\n return sub_datasets"],"string":"[\n \"def test_expand_experiments():\\n template_script = get_template_script()\\n experiment_systems = utils.CombinatorialLeaf(['explicit-system', 'implicit-system', 'hydration-system'])\\n template_script['experiments']['system'] = experiment_systems\\n\\n exp_builder = ExperimentBuilder(script=template_script, job_id=1, n_jobs=2)\\n experiments = list(exp_builder._expand_experiments())\\n assert len(experiments) == 2\\n\\n exp_builder = ExperimentBuilder(script=template_script, job_id=2, n_jobs=2)\\n experiments = list(exp_builder._expand_experiments())\\n assert len(experiments) == 1\",\n \"def set_sub_models(self):\\r\\n sub_data_grid = [0.1 * i for i in range(1, 10)]\\r\\n self.sub_models = [\\r\\n copy.deepcopy(self.model_) for _ in range(len(sub_data_grid))]\\r\\n # fit sub-models to subset of data\\r\\n for key, data_size in enumerate(sub_data_grid):\\r\\n X, _, y, _ = train_test_split(\\r\\n self.X_train, self.y_train.ravel(),\\r\\n train_size=data_size,\\r\\n random_state=self.seeds.get('l_curve_seed', 22))\\r\\n self.sub_models[key].fit(X, y)\",\n \"def get_subensemble_parts(self, num_parts):\\n parts = []\\n\\n decoder_parts = self.get_subensemble_decoder(num_parts, \\\"X\\\")\\n\\n encoder_length = len(self.encoders)\\n bias_length = len(self.bias)\\n\\n # create the specified number of subensembles\\n for e_num in range(1, num_parts + 1):\\n e_size = encoder_length / num_parts\\n b_size = bias_length / num_parts\\n\\n encoder_part = self.encoders[e_size * (e_num - 1):e_size * e_num]\\n bias_part = self.bias[b_size * (e_num - 1):b_size * e_num]\\n\\n parts.append((encoder_part, decoder_parts[e_num - 1], bias_part))\\n\\n return parts\",\n \"def splits(cls, exts, fields, root='/Users/yingliu/PycharmProjects/Seq2SeqSemantic/data/',\\n train='train2', validation='val2', test='test2', **kwargs):\\n return super(SPDataset, cls).splits(\\n exts, fields, path=root,\\n train = train, validation = validation, test = test, **kwargs)\",\n \"def _build_experiment_embedded_list():\\n pass\",\n \"def split_test_data():\\n outputvis = ROOT_DIR + 'test_imaging/test_split_1eb.ms'\\n targ = TARGETS['NGC1333IRAS4A']\\n spw = '{0}:236~276'.format(SPWS[targ.name]['NH3_11'].spw_id)\\n split(\\n vis=get_vis_name(targ),\\n outputvis=outputvis,\\n field=targ.name,\\n spw=spw,\\n )\",\n \"def create_sub_mdps(self, level):\\n\\n mdps_copy = set(self.mdps[level-1].copy())\\n mdps = set()\\n upper_level_exits = {}\\n\\n # Full depth-first search to group MDPs into MERs\\n while len(mdps_copy) > 0:\\n curr_mdp = random.choice(tuple(mdps_copy))\\n mer, exits = set(), set()\\n # Group curr_mdp with neighbors to form a MER and find exits\\n self.dfs(mdps_copy, curr_mdp, level, mer, exits)\\n # Choose a state var that is representative of the new MER\\n state_var = next(iter(mer)).state_var[1:]\\n # Create a new upper level MDP and set its properties\\n mdp = MDP(level=level, state_var=state_var)\\n mdp.mer = frozenset(mer)\\n\\n upper_level_exits[mdp] = exits\\n for _mdp in mer:\\n mdp.primitive_states.update(_mdp.primitive_states)\\n mdps.add(mdp)\\n\\n self.mdps[level] = mdps\\n\\n # Add MDP Exits/Actions\\n for mdp in self.mdps[level]:\\n mdp.exits = set()\\n # Generate new exits (mdp at level, Exit at level-1, target mdp at level)\\n for s_mdp, exit, n_mdp in upper_level_exits[mdp]:\\n neighbor_mdp = n_mdp.get_upper_mdp(self.mdps) \\n mdp.exits.add(Exit(mdp, Exit(s_mdp, exit, n_mdp), neighbor_mdp))\",\n \"def setup_experiment(testruns, droplist=\\\"\\\"):\\n ex = Experiment()\\n ex.addSoluFile(ALL_SOLU)\\n\\n regexlist = []\\n for x in droplist.split(\\\",\\\"):\\n # defaultvalue, if empty we don't want to exclude everything\\n if x == \\\"\\\":\\n continue\\n try:\\n y = re.compile(x)\\n regexlist.append(y)\\n except:\\n pass\\n\\n excluded_inst = []\\n # get data\\n for t in testruns:\\n # update representation\\n additional_data = {\\\"RubberbandId\\\": get_rbid_representation(t, \\\"extended\\\")}\\n\\n # collect data and pass to ipet\\n ipettestrun = TestRun()\\n tr_raw_data = t.get_data(add_data=additional_data)\\n\\n tr_data = {}\\n for i in tr_raw_data.keys():\\n for r in regexlist:\\n if r.match(i):\\n excluded_inst.append(i)\\n break\\n else:\\n tr_data[i] = tr_raw_data[i]\\n\\n ipettestrun.data = pd.DataFrame(tr_data).T\\n\\n ex.testruns.append(ipettestrun)\\n return ex, excluded_inst\",\n \"def split_dataset(dataset, eval_proportion, shuffle=False):\\n split_sizes = [1. - eval_proportion, eval_proportion]\\n split_frames = []\\n split_demos = []\\n num_demos = dataset.get_num_demos()\\n split_num_demos = [int(fraction * num_demos) for fraction in split_sizes]\\n split_num_demos[0] += num_demos - sum(split_num_demos)\\n num_instances = len(dataset)\\n demos = list(range(num_demos))\\n if shuffle:\\n np.random.shuffle(demos)\\n start_idx = 0\\n for split_idx in range(len(split_sizes)):\\n if split_sizes[split_idx] == 0:\\n split_frames.append(None)\\n continue\\n split_frames.append([])\\n split_demos.append(range(start_idx, start_idx + split_num_demos[split_idx]))\\n for demo_idx in split_demos[split_idx]:\\n demo_slice = dataset.get_demo_frame_idxs(demos[demo_idx])\\n split_frames[split_idx].extend(\\n list(range(demo_slice.start, demo_slice.stop)))\\n start_idx += split_num_demos[split_idx]\\n # Check if the split indices are unique\\n assert len(set(split_frames[split_idx])) == len(split_frames[split_idx])\\n\\n if eval_proportion > 0:\\n # Check that splits do not intersect\\n for split_idx in range(len(split_frames)):\\n for split_idx2 in range(split_idx + 1, len(split_frames)):\\n assert len(set(split_frames[split_idx]).intersection(split_frames[split_idx2])) == 0\\n assert sum([len(s) for s in split_frames]) == num_instances\\n\\n split_datasets = [Subset(dataset, split) if split is not None else None for split in split_frames]\\n return split_datasets\",\n \"def subanalyses(self, subject_id, data):\\n raise NotImplementedError('not implemented in abstract class')\",\n \"def build_experiments(self):\\n\\n # width=500, height=350, pos_x= 2.0, pos_y=0.0, pos_z= 1.4, angle=-30.0\\n cameraRGB = Camera('Camera', PostProcessing='SceneFinal')\\n cameraRGB.set_image_size(500, 350)\\n cameraRGB.set_position(2.0, 0.0, 1.4)\\n cameraRGB.set_rotation(-30.0, 0.0, 0.)\\n cameraRGB.set(FOV=100)\\n\\n camera = Camera('CameraSem', PostProcessing='SemanticSegmentation')\\n camera.set_image_size(320, 180)\\n camera.set_position(2.0, 0.0, 1.4)\\n camera.set_rotation(-30.0, 0.0, 0.)\\n camera.set(FOV=100)\\n\\n if self._city_name == 'Town01':\\n poses_tasks = self._poses_town01()\\n vehicles_tasks = []\\n pedestrians_tasks = []\\n for i in range(len(poses_tasks)):\\n vehicles_tasks.append(0)\\n pedestrians_tasks.append(0)\\n\\n experiment_vector = []\\n\\n for weather in self.weathers:\\n\\n for iteration in range(len(poses_tasks)):\\n poses = poses_tasks[iteration]\\n vehicles = vehicles_tasks[iteration]\\n pedestrians = pedestrians_tasks[iteration]\\n\\n conditions = CarlaSettings()\\n conditions.set(\\n SendNonPlayerAgentsInfo=True,\\n NumberOfVehicles=vehicles,\\n NumberOfPedestrians=pedestrians,\\n WeatherId=weather,\\n QualityLevel=1\\n )\\n\\n conditions.set(SynchronousMode=True)\\n conditions.set(DisableTwoWheeledVehicles=True)\\n\\n conditions.add_sensor(camera)\\n conditions.add_sensor(cameraRGB)\\n\\n experiment = Experiment()\\n experiment.set(\\n Conditions=conditions,\\n Poses=poses,\\n Task=iteration,\\n Repetitions=1\\n )\\n\\n experiment_vector.append(experiment)\\n\\n return experiment_vector\",\n \"def setUp(self):\\n self.splits = (2,3,4)\",\n \"def three_experiments(two_experiments, one_experiment):\",\n \"def _split(self, split, randomise=False, **kwargs):\\r\\n # Copy split to prevent modifying outside arguments\\r\\n split = split.copy()\\r\\n # Compute total\\r\\n total = sum(split.values())\\r\\n # If split contains floats, convert to integers\\r\\n if isinstance(total, float):\\r\\n assert_msg = 'Not enough data! ' \\\\\\r\\n + f'Split requires a total of {total*100}%. ' \\\\\\r\\n + 'Split should not exceed 100%.'\\r\\n assert total <= 1, assert_msg\\r\\n # Add 'rest' subset if not all data is used in split\\r\\n if total < 1:\\r\\n split['rest'] = 1 - total\\r\\n split = self._float_split_to_int(split)\\r\\n total = sum(split.values())\\r\\n # Create subsets based off integer values\\r\\n if isinstance(total, int):\\r\\n assert_msg = 'Not enough data! ' \\\\\\r\\n + f'Split requires a total of {total} data entries ' \\\\\\r\\n + f'but only {len(self.data)} are available.'\\r\\n assert total <= len(self.data), assert_msg\\r\\n # Add 'rest' subset if not all data is used in split\\r\\n if total < len(self.data):\\r\\n split['rest'] = len(self.data) - total\\r\\n # Create subsets\\r\\n index = 0\\r\\n for name, length in split.items():\\r\\n subset_name = f'{self.name}.{name}'\\r\\n subset_data = self.data[index:index + length]\\r\\n subset_seed = self.seed\\r\\n if self.seed is not None:\\r\\n subset_seed += sum([ord(c) for c in name]) + length\\r\\n subset = self._make_subset(subset_name,\\r\\n subset_data,\\r\\n randomise=randomise,\\r\\n seed=subset_seed,\\r\\n **kwargs\\r\\n )\\r\\n setattr(self, name, subset)\\r\\n index += length\\r\\n # Replace data with references to subsets\\r\\n self.data = []\\r\\n for name in split.keys():\\r\\n self.data.append(getattr(self, name, None))\\r\\n # Indicate that this is a superset\\r\\n self.is_superset = True\",\n \"def make_multiinstantiate(self, special_properties, name, parameters):\\n PARAM_SUBSCRIPT = \\\"_p\\\"\\n self._model_namespace[\\\"ct_populationname\\\"] = name+\\\"Multi\\\"\\n multi_ct = lems.ComponentType(self._model_namespace[\\\"ct_populationname\\\"], extends=BASE_POPULATION)\\n structure = lems.Structure()\\n multi_ins = lems.MultiInstantiate(component_type=name,\\n number=\\\"N\\\")\\n param_dict = {}\\n # number of neruons\\n multi_ct.add(lems.Parameter(name=\\\"N\\\", dimension=\\\"none\\\"))\\n # other parameters\\n for sp in special_properties:\\n if special_properties[sp] is None:\\n multi_ct.add(lems.Parameter(name=sp+PARAM_SUBSCRIPT, dimension=self._all_params_unit[sp]))\\n multi_ins.add(lems.Assign(property=sp, value=sp+PARAM_SUBSCRIPT))\\n param_dict[sp] = parameters[sp]\\n else:\\n # multi_ct.add(lems.Parameter(name=sp, dimension=self._all_params_unit[sp]))\\n # check if there are some units in equations\\n equation = special_properties[sp]\\n # add spaces around brackets to prevent mismatching\\n equation = re.sub(\\\"\\\\(\\\", \\\" ( \\\", equation)\\n equation = re.sub(\\\"\\\\)\\\", \\\" ) \\\", equation)\\n for i in get_identifiers(equation):\\n # iterator is a special case\\n if i == \\\"i\\\":\\n regexp_noletter = \\\"[^a-zA-Z0-9]\\\"\\n equation = re.sub(\\\"{re}i{re}\\\".format(re=regexp_noletter),\\n \\\" {} \\\".format(INDEX), equation)\\n # here it's assumed that we don't use Netwton in neuron models\\n elif i in name_to_unit and i != \\\"N\\\":\\n const_i = i+'const'\\n multi_ct.add(lems.Constant(name=const_i, symbol=const_i,\\n dimension=self._all_params_unit[sp], value=\\\"1\\\"+i))\\n equation = re.sub(i, const_i, equation)\\n multi_ins.add(lems.Assign(property=sp, value=equation))\\n structure.add(multi_ins)\\n multi_ct.structure = structure\\n self._model.add(multi_ct)\\n param_dict = dict([(k+\\\"_p\\\", v) for k, v in param_dict.items()])\\n param_dict[\\\"N\\\"] = self._nr_of_neurons\\n self._model_namespace[\\\"populationname\\\"] = self._model_namespace[\\\"ct_populationname\\\"] + \\\"pop\\\"\\n self._model_namespace[\\\"networkname\\\"] = self._model_namespace[\\\"ct_populationname\\\"] + \\\"Net\\\"\\n self.add_population(self._model_namespace[\\\"networkname\\\"],\\n self._model_namespace[\\\"populationname\\\"],\\n self._model_namespace[\\\"ct_populationname\\\"],\\n **param_dict)\",\n \"def get_subensemble_decoder(self, num_parts, origin_name, func=None):\\n parts = []\\n\\n # TODO do not require an Origin to be created just to compute decoder\\n if origin_name not in self.origin:\\n # create the origin in order to compute a decoder\\n self.add_origin(origin_name, func)\\n # print \\\"name \\\" + self.name + \\\" decoder: \\\" + str(self.origin[origin_name].decoder)\\n\\n decoder = self.origin[origin_name].decoder\\n decoder_length = len(decoder)\\n\\n # create the specified number of decoders\\n for e_num in range(1, num_parts + 1):\\n d_size = decoder_length / num_parts\\n decoder_part = decoder[d_size * (e_num - 1):d_size * e_num]\\n\\n parts.append(decoder_part)\\n\\n return parts\",\n \"def generate_submissons_all_steps():\\n\\n\\n data_en = read_json_file(\\\"Test_Data/test-en.json\\\")\\n data_pr = read_json_file(\\\"Test_Data/test-pr.json\\\")\\n data_es = read_json_file(\\\"Test_Data/test-es.json\\\")\\n res_en = generate_embeddings_sentence_test_data(data_en, \\\"Test_Data/embd-en.pkl\\\")\\n res_es = generate_embeddings_sentence_test_data(data_es, \\\"Test_Data/embd-es.pkl\\\")\\n res_pr = generate_embeddings_sentence_test_data(data_pr, \\\"Test_Data/embd-pr.pkl\\\")\\n model = load_model(\\\"model_doc\\\")\\n make_submission(res_es, model, \\\"submission-es\\\")\\n make_submission(res_pr, model, \\\"submission-pr\\\")\\n make_submission(res_en, model, \\\"submission-en\\\")\\n exit()\",\n \"def decode(self):\\n # Extract all the experiments\\n\\n # Map of imageset/scan pairs\\n imagesets = {}\\n\\n # For every experiment, use the given input to create\\n # a sensible experiment.\\n el = ExperimentList()\\n for eobj in self._obj[\\\"experiment\\\"]:\\n\\n # Get the models\\n identifier = eobj.get(\\\"identifier\\\", \\\"\\\")\\n beam = self._lookup_model(\\\"beam\\\", eobj)\\n detector = self._lookup_model(\\\"detector\\\", eobj)\\n goniometer = self._lookup_model(\\\"goniometer\\\", eobj)\\n scan = self._lookup_model(\\\"scan\\\", eobj)\\n crystal = self._lookup_model(\\\"crystal\\\", eobj)\\n profile = self._lookup_model(\\\"profile\\\", eobj)\\n scaling_model = self._lookup_model(\\\"scaling_model\\\", eobj)\\n\\n key = (eobj.get(\\\"imageset\\\"), eobj.get(\\\"scan\\\"))\\n\\n imageset = None\\n try:\\n imageset = imagesets[key] # type: ImageSet\\n except KeyError:\\n # This imageset hasn't been loaded yet - create it\\n imageset_data = self._lookup_model(\\\"imageset\\\", eobj)\\n\\n # Create the imageset from the input data\\n if imageset_data is not None:\\n if \\\"params\\\" in imageset_data:\\n format_kwargs = imageset_data[\\\"params\\\"]\\n else:\\n format_kwargs = {}\\n\\n # Load the external lookup data\\n mask_filename, mask = self._load_pickle_path(imageset_data, \\\"mask\\\")\\n gain_filename, gain = self._load_pickle_path(imageset_data, \\\"gain\\\")\\n pedestal_filename, pedestal = self._load_pickle_path(\\n imageset_data, \\\"pedestal\\\"\\n )\\n dx_filename, dx = self._load_pickle_path(imageset_data, \\\"dx\\\")\\n dy_filename, dy = self._load_pickle_path(imageset_data, \\\"dy\\\")\\n\\n if imageset_data[\\\"__id__\\\"] == \\\"ImageSet\\\":\\n imageset = self._make_stills(\\n imageset_data, format_kwargs=format_kwargs\\n )\\n elif imageset_data[\\\"__id__\\\"] == \\\"ImageGrid\\\":\\n imageset = self._make_grid(\\n imageset_data, format_kwargs=format_kwargs\\n )\\n elif (\\n imageset_data[\\\"__id__\\\"] == \\\"ImageSequence\\\"\\n or imageset_data[\\\"__id__\\\"] == \\\"ImageSweep\\\"\\n ):\\n imageset = self._make_sequence(\\n imageset_data,\\n beam=beam,\\n detector=detector,\\n goniometer=goniometer,\\n scan=scan,\\n format_kwargs=format_kwargs,\\n )\\n elif imageset_data[\\\"__id__\\\"] == \\\"MemImageSet\\\":\\n imageset = self._make_mem_imageset(imageset_data)\\n else:\\n raise RuntimeError(\\\"Unknown imageset type\\\")\\n\\n if imageset is not None:\\n # Set the external lookup\\n if mask is None:\\n mask = ImageBool()\\n else:\\n mask = ImageBool(mask)\\n if gain is None:\\n gain = ImageDouble()\\n else:\\n gain = ImageDouble(gain)\\n if pedestal is None:\\n pedestal = ImageDouble()\\n else:\\n pedestal = ImageDouble(pedestal)\\n if dx is None:\\n dx = ImageDouble()\\n else:\\n dx = ImageDouble(dx)\\n if dy is None:\\n dy = ImageDouble()\\n else:\\n dy = ImageDouble(dy)\\n\\n if not imageset.external_lookup.mask.data.empty():\\n if not mask.empty():\\n mask = tuple(m.data() for m in mask)\\n for m1, m2 in zip(\\n mask, imageset.external_lookup.mask.data\\n ):\\n m1 &= m2.data()\\n imageset.external_lookup.mask.data = ImageBool(mask)\\n else:\\n imageset.external_lookup.mask.data = mask\\n imageset.external_lookup.mask.filename = mask_filename\\n imageset.external_lookup.gain.data = gain\\n imageset.external_lookup.gain.filename = gain_filename\\n imageset.external_lookup.pedestal.data = pedestal\\n imageset.external_lookup.pedestal.filename = pedestal_filename\\n imageset.external_lookup.dx.data = dx\\n imageset.external_lookup.dx.filename = dx_filename\\n imageset.external_lookup.dy.data = dy\\n imageset.external_lookup.dy.filename = dy_filename\\n\\n # Update the imageset models\\n if isinstance(imageset, ImageSequence):\\n imageset.set_beam(beam)\\n imageset.set_detector(detector)\\n imageset.set_goniometer(goniometer)\\n imageset.set_scan(scan)\\n elif isinstance(imageset, (ImageSet, ImageGrid)):\\n for i in range(len(imageset)):\\n imageset.set_beam(beam, i)\\n imageset.set_detector(detector, i)\\n imageset.set_goniometer(goniometer, i)\\n imageset.set_scan(scan, i)\\n\\n imageset.update_detector_px_mm_data()\\n\\n # Add the imageset to the dict - even if empty - as this will\\n # prevent a duplicated attempt at reconstruction\\n imagesets[key] = imageset\\n\\n # Append the experiment\\n el.append(\\n Experiment(\\n imageset=imageset,\\n beam=beam,\\n detector=detector,\\n goniometer=goniometer,\\n scan=scan,\\n crystal=crystal,\\n profile=profile,\\n scaling_model=scaling_model,\\n identifier=identifier,\\n )\\n )\\n\\n # Return the experiment list\\n return el\",\n \"def train_data_split(self, selected_sr, selected_ss):\\n \\\"\\\"\\\"\\n Arguments:\\n selected_sr: ordinal number of the selected split ratio\\n selected_ss: ordinal number of split shift\\n \\\"\\\"\\\"\\n assert selected_sr < len(self.split_ratios),\\\\\\n \\\"The total number of possible split ratios is: %d\\\"\\\\\\n % len(self.split_ratios)\\n\\n max_shifts = 100 / self.split_ratios[selected_sr][-1]\\n\\n assert selected_ss < max_shifts,\\\\\\n \\\"The total number of split shifts is: %d\\\" % max_shifts\\n\\n self.empty_split()\\n\\n n = float(self.n_train) / max_shifts\\n self.n_develop = int(self.split_ratios[selected_sr][0] /\\n (100 / max_shifts) * n)\\n\\n self.n_valid = int(self.split_ratios[selected_sr][1] /\\n (100 / max_shifts) * n)\\n\\n self.n_eval = self.n_train - self.n_develop - self.n_valid\\n\\n for i in range(self.n_develop):\\n self.development_subjects.\\\\\\n append(self.training_subjects[(selected_ss * self.n_eval + i) %\\n self.n_train])\\n\\n for i in range(self.n_valid):\\n self.validation_subjects.\\\\\\n append(self.training_subjects[(selected_ss * self.n_eval +\\n self.n_develop + i) %\\n self.n_train])\\n\\n for i in range(self.n_eval):\\n self.evaluation_subjects.\\\\\\n append(self.training_subjects[(selected_ss * self.n_eval +\\n self.n_develop +\\n self.n_valid + i) %\\n self.n_train])\",\n \"def __init__(self, transform, num_subbursts=1, parts_subset=None, \\n pct_subset=None, balance=True, random_start_points=False, seed1=4, seed2=33):\\n self.dp = DataPipeline(\\\"\\\",\\\"\\\")\\n self.metadata = self.dp.get_metadata()\\n if parts_subset:\\n self.metadata = self.metadata[self.metadata.part.isin(parts_subset)]\\n if pct_subset:\\n self.metadata = self.metadata.sample(frac=pct_subset, random_state=seed1)\\n if balance:\\n reals = self.metadata[self.metadata.label=='REAL']\\n self.num_reals = len(reals)\\n fakes = self.metadata[self.metadata.label=='FAKE']\\n fakes = fakes.sample(n=self.num_reals, random_state=seed2)\\n self.metadata = pd.concat([reals,fakes])\\n\\n self.num_subbursts = num_subbursts\\n self.transform = transform\\n self.padding = PADDING_CROP\\n self.random_start_points = random_start_points\",\n \"def make_data_splits(samples, params, RESULTSDIR, num_experiments):\\n # TODO: Switch to .mat from .pickle so that these lists are easier to read\\n # and change.\\n\\n partition = {}\\n if params[\\\"load_valid\\\"] is None:\\n # Set random seed if included in params\\n if params[\\\"data_split_seed\\\"] is not None:\\n np.random.seed(params[\\\"data_split_seed\\\"])\\n\\n all_inds = np.arange(len(samples))\\n\\n # extract random inds from each set for validation\\n v = params[\\\"num_validation_per_exp\\\"]\\n valid_inds = []\\n if params[\\\"valid_exp\\\"] is not None and params[\\\"num_validation_per_exp\\\"] > 0:\\n all_valid_inds = []\\n for e in params[\\\"valid_exp\\\"]:\\n tinds = [\\n i for i in range(len(samples)) if int(samples[i].split(\\\"_\\\")[0]) == e\\n ]\\n all_valid_inds = all_valid_inds + tinds\\n valid_inds = valid_inds + list(\\n np.random.choice(tinds, (v,), replace=False)\\n )\\n valid_inds = list(np.sort(valid_inds))\\n\\n train_inds = list(set(all_inds) - set(all_valid_inds))#[i for i in all_inds if i not in all_valid_inds]\\n elif params[\\\"num_validation_per_exp\\\"] > 0: # if 0, do not perform validation\\n for e in range(num_experiments):\\n tinds = [\\n i for i in range(len(samples)) if int(samples[i].split(\\\"_\\\")[0]) == e\\n ]\\n valid_inds = valid_inds + list(\\n np.random.choice(tinds, (v,), replace=False)\\n )\\n valid_inds = list(np.sort(valid_inds))\\n\\n train_inds = [i for i in all_inds if i not in valid_inds]\\n elif params[\\\"valid_exp\\\"] is not None:\\n raise Exception(\\\"Need to set num_validation_per_exp in using valid_exp\\\")\\n else:\\n train_inds = all_inds\\n\\n assert (set(valid_inds) & set(train_inds)) == set()\\n\\n train_samples = samples[train_inds]\\n train_inds = []\\n if params[\\\"valid_exp\\\"] is not None:\\n train_expts = [f for f in range(num_experiments) if f not in params[\\\"valid_exp\\\"]]\\n else:\\n train_expts = np.arange(num_experiments)\\n\\n print(\\\"TRAIN EXPTS: {}\\\".format(train_expts))\\n\\n if params[\\\"num_train_per_exp\\\"] is not None:\\n # Then sample randomly without replacement from training sampleIDs\\n for e in train_expts:\\n tinds = [\\n i for i in range(len(train_samples)) if int(train_samples[i].split(\\\"_\\\")[0]) == e\\n ]\\n print(e)\\n print(len(tinds))\\n train_inds = train_inds + list(\\n np.random.choice(tinds, (params[\\\"num_train_per_exp\\\"],), replace=False)\\n )\\n train_inds = list(np.sort(train_inds))\\n else:\\n train_inds = np.arange(len(train_samples))\\n\\n \\n\\n partition[\\\"valid_sampleIDs\\\"] = samples[valid_inds]\\n partition[\\\"train_sampleIDs\\\"] = train_samples[train_inds]\\n\\n # Save train/val inds\\n with open(os.path.join(RESULTSDIR, \\\"val_samples.pickle\\\"), \\\"wb\\\") as f:\\n cPickle.dump(partition[\\\"valid_sampleIDs\\\"], f)\\n\\n with open(os.path.join(RESULTSDIR, \\\"train_samples.pickle\\\"), \\\"wb\\\") as f:\\n cPickle.dump(partition[\\\"train_sampleIDs\\\"], f)\\n else:\\n # Load validation samples from elsewhere\\n with open(os.path.join(params[\\\"load_valid\\\"], \\\"val_samples.pickle\\\"), \\\"rb\\\",) as f:\\n partition[\\\"valid_sampleIDs\\\"] = cPickle.load(f)\\n partition[\\\"train_sampleIDs\\\"] = [\\n f for f in samples if f not in partition[\\\"valid_sampleIDs\\\"]\\n ]\\n\\n # Reset any seeding so that future batch shuffling, etc. are not tied to this seed\\n if params[\\\"data_split_seed\\\"] is not None:\\n np.random.seed()\\n\\n return partition\",\n \"def _create_examples_split(self, lines, set_type):\\n examples = []\\n \\n for (i, line) in enumerate(lines):\\n a_label = int(line[\\\"label\\\"])\\n q_type = line[\\\"type\\\"]\\n if a_label == 0 and q_type != \\\"qLookup\\\":\\n #print(\\\"discontinue\\\")\\n continue\\n sentence_number = 0\\n premise_text = line[\\\"premise\\\"]\\n the_id = int(line[\\\"id\\\"])\\n modified_premise_text = re.sub(self.stage_name_pattern,\\\"\\\",premise_text)\\n modified_premise_text = re.sub(self.w_patterns,\\\"\\\",modified_premise_text)\\n hypothesis_text = line[\\\"hypothesis\\\"]\\n hypothesis_text = re.sub(self.w_patterns,\\\"\\\",hypothesis_text)\\n \\n\\n sentences = modified_premise_text.split('.')\\n\\n for j, sentence in enumerate(sentences):\\n guid = \\\"\\\" + str(sentence_number) + \\\"\\\\t\\\" + str(i) + \\\"\\\\t\\\" + str(len(sentences)) + \\\"\\\\t\\\" + str(a_label)\\n text_a = sentence\\n text_b = hypothesis_text\\n label = a_label\\n sentence_number += 1\\n examples.append(\\n InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n #print(\\\"16th sentence::\\\",sentences[16])\\n\\n return examples\",\n \"def generate_complex_catalog(stem: str = '') -> cat.Catalog:\\n group_a = generators.generate_sample_model(cat.Group, True)\\n group_a.id = f'{stem}a'\\n group_a.controls = generate_control_list(group_a.id, 4)\\n part = generators.generate_sample_model(common.Part)\\n part.id = f'{stem}a-1_smt'\\n part.parts = None\\n group_a.controls[0].parts[0].id = f'{stem}_part_with_subpart'\\n group_a.controls[0].parts[0].parts = [part]\\n group_b = generators.generate_sample_model(cat.Group, True)\\n group_b.id = f'{stem}b'\\n group_b.controls = generate_control_list(group_b.id, 3)\\n group_b.controls[2].controls = generate_control_list(f'{group_b.id}-2', 3)\\n group_ba = generators.generate_sample_model(cat.Group, True)\\n group_ba.id = f'{stem}ba'\\n group_ba.controls = generate_control_list(group_ba.id, 2)\\n group_b.groups = [group_ba]\\n\\n catalog = generators.generate_sample_model(cat.Catalog, True)\\n catalog.controls = generate_control_list(f'{stem}cat', 3)\\n catalog.params = generate_param_list(f'{stem}parm', 3)\\n\\n test_control = generators.generate_sample_model(cat.Control, False)\\n test_control.id = f'{stem}test-1'\\n test_control.params = [common.Parameter(id=f'{test_control.id}_prm_1', values=['Default', 'Values'])]\\n test_control.parts = [\\n common.Part(\\n id=f'{test_control.id}-stmt', prose='The prose with {{ insert: param, test-1_prm_1 }}', name='statement'\\n )\\n ]\\n catalog.controls.append(test_control)\\n catalog.groups = [group_a, group_b]\\n\\n return catalog\",\n \"def create_new_individuals(design, problem, pop_size=None):\\n\\n if pop_size is None:\\n pop_size_options = [50, 105, 120, 126, 132, 112, 156, 90, 275]\\n pop_size = pop_size_options[problem.num_of_objectives - 2]\\n\\n if design == \\\"RandomDesign\\\":\\n lower_limits = np.asarray(problem.get_variable_lower_bounds())\\n upper_limits = np.asarray(problem.get_variable_upper_bounds())\\n individuals = np.random.random((pop_size, problem.n_of_variables))\\n # Scaling\\n individuals = individuals * (upper_limits - lower_limits) + lower_limits\\n\\n return individuals\\n\\n elif design == \\\"LHSDesign\\\":\\n lower_limits = np.asarray(problem.get_variable_lower_bounds())\\n upper_limits = np.asarray(problem.get_variable_upper_bounds())\\n individuals = lhs(problem.n_of_variables, samples=pop_size)\\n # Scaling\\n individuals = individuals * (upper_limits - lower_limits) + lower_limits\\n\\n return individuals\\n\\n elif design == \\\"EvoNN\\\":\\n\\n \\\"\\\"\\\"Create a population of neural networks for the EvoNN algorithm.\\n\\n Individuals are 2d arrays representing the weight matrices of the NNs.\\n One extra row is added for bias.\\n\\n \\\"\\\"\\\"\\n\\n w_low = problem.params[\\\"w_low\\\"]\\n w_high = problem.params[\\\"w_high\\\"]\\n in_nodes = problem.num_of_variables\\n num_nodes = problem.params[\\\"num_nodes\\\"]\\n prob_omit = problem.params[\\\"prob_omit\\\"]\\n\\n individuals = np.random.uniform(\\n w_low, w_high, size=(pop_size, in_nodes, num_nodes)\\n )\\n\\n # Randomly set some weights to zero\\n zeros = np.random.choice(\\n np.arange(individuals.size), ceil(individuals.size * prob_omit)\\n )\\n individuals.ravel()[zeros] = 0\\n\\n # Set bias\\n individuals = np.insert(individuals, 0, 1, axis=1)\\n\\n return individuals\\n\\n elif design == \\\"EvoDN2\\\":\\n \\\"\\\"\\\"Create a population of deep neural networks (DNNs) for the EvoDN2 algorithm.\\n\\n Each individual is a list of subnets, and each subnet contains a random amount\\n of layers and\\n nodes per layer. The subnets are evolved via evolutionary algorithms, and they\\n converge\\n on the final linear layer of the DNN.\\n \\\"\\\"\\\"\\n\\n individuals = []\\n for i in range(problem.params[\\\"pop_size\\\"]):\\n nets = []\\n for j in range(problem.params[\\\"num_subnets\\\"]):\\n\\n layers = []\\n num_layers = np.random.randint(1, problem.params[\\\"max_layers\\\"])\\n in_nodes = len(problem.subsets[j])\\n\\n for k in range(num_layers):\\n out_nodes = random.randint(2, problem.params[\\\"max_nodes\\\"])\\n net = np.random.uniform(\\n problem.params[\\\"w_low\\\"],\\n problem.params[\\\"w_high\\\"],\\n size=(in_nodes, out_nodes),\\n )\\n # Randomly set some weights to zero\\n zeros = np.random.choice(\\n np.arange(net.size),\\n ceil(net.size * problem.params[\\\"prob_omit\\\"]),\\n )\\n net.ravel()[zeros] = 0\\n\\n # Add bias\\n net = np.insert(net, 0, 1, axis=0)\\n in_nodes = out_nodes\\n layers.append(net)\\n\\n nets.append(layers)\\n\\n individuals.append(nets)\\n\\n return individuals\\n\\n elif design == \\\"BioGP\\\":\\n return problem.create_individuals()\",\n \"def gen_submodels(self, model, options):\\n for submodel in options:\\n model.submodels.create(id=submodel)\",\n \"def new_multi_experiments_from_components(self, dataset_params,\\n input_params,\\n architecture, model_params,\\n train_params=None):\\n # Assuming they're all list\\n components = [dataset_params, input_params, architecture, model_params,\\n train_params if train_params else [None]]\\n args_list = product(*components)\\n\\n inserted_ids = []\\n for args in args_list:\\n inserted_ids.append(\\n self.new_multi_experiments_from_components(*args))\\n return inserted_ids\",\n \"def three_experiments_branch_same_name_trials(\\n three_experiments_branch_same_name, orionstate, storage\\n):\\n exp1 = experiment_builder.build(name=\\\"test_single_exp\\\", version=1, storage=storage)\\n exp2 = experiment_builder.build(name=\\\"test_single_exp\\\", version=2, storage=storage)\\n exp3 = experiment_builder.build(\\n name=\\\"test_single_exp_child\\\", version=1, storage=storage\\n )\\n\\n x = {\\\"name\\\": \\\"/x\\\", \\\"type\\\": \\\"real\\\"}\\n y = {\\\"name\\\": \\\"/y\\\", \\\"type\\\": \\\"real\\\"}\\n z = {\\\"name\\\": \\\"/z\\\", \\\"type\\\": \\\"real\\\"}\\n x_value = 0.0\\n for status in Trial.allowed_stati:\\n x[\\\"value\\\"] = x_value + 0.1 # To avoid duplicates\\n y[\\\"value\\\"] = x_value * 10\\n z[\\\"value\\\"] = x_value * 100\\n trial1 = Trial(experiment=exp1.id, params=[x], status=status)\\n trial2 = Trial(experiment=exp2.id, params=[x, y], status=status)\\n trial3 = Trial(experiment=exp3.id, params=[x, y, z], status=status)\\n # Add a child to a trial from exp1\\n child = trial1.branch(params={\\\"/x\\\": 1})\\n orionstate.database.write(\\\"trials\\\", trial1.to_dict())\\n orionstate.database.write(\\\"trials\\\", trial2.to_dict())\\n orionstate.database.write(\\\"trials\\\", trial3.to_dict())\\n orionstate.database.write(\\\"trials\\\", child.to_dict())\\n x_value += 1\\n # exp1 should have 12 trials (including child trials)\\n # exp2 and exp3 should have 6 trials each\\n\\n # Add some algo data for exp1\\n orionstate.database.read_and_write(\\n collection_name=\\\"algo\\\",\\n query={\\\"experiment\\\": exp1.id},\\n data={\\n \\\"state\\\": pickle.dumps(\\n {\\\"my_algo_state\\\": \\\"some_data\\\", \\\"my_other_state_data\\\": \\\"some_other_data\\\"}\\n )\\n },\\n )\",\n \"def split(self, fractions=[0.8, 0.2]):\\n\\n if sum(fractions) > 1.0 or sum(fractions) <= 0:\\n raise ValueError(\\\"the sum of fractions argument should be between 0 and 1\\\")\\n\\n # random indices\\n idx = np.arange(self.n_samples)\\n np.random.shuffle(idx)\\n\\n # insert zero\\n fractions.insert(0, 0)\\n\\n # gte limits of the subsets\\n limits = (np.cumsum(fractions) * self.n_samples).astype(np.int32)\\n\\n subsets = []\\n # create output dataset\\n for i in range(len(fractions) - 1):\\n subsets.append(\\n Dataset(self.inputs[idx[limits[i]:limits[i + 1]]], self.targets[idx[limits[i]:limits[i + 1]]]))\\n\\n return subsets\",\n \"def init_subgroups(metadata):\\n dictionary = {'dataframe': metadata}\\n subgroups = [dictionary]\\n\\n return subgroups\",\n \"def experiment(worker):\\n if worker == 0:\\n logging.info('Start.')\\n\\n surv = np.zeros((NUM_GEN, NUM_CRS, 2), dtype=float)\\n # order = np.zeros((NUM_GEN, NUM_CRS, NUM_G), dtype=float) # time + orders\\n ctrl = np.zeros((NUM_GEN, NUM_LIN, 2), dtype=float)\\n\\n # Initiation of lineages\\n ancestor = Generation(species=SPECIES, N=NUM_INDV, environment=ENVIRONMENT)\\n ancestor.natural_selection()\\n lineages = [deepcopy(ancestor) for _ in range(NUM_LIN)]\\n\\n if worker == 0:\\n logging.info('Lineages are initiated.')\\n\\n # BUG: Need to run analysis for the ancestral population!\\n\\n # Evolution\\n for t in range(NUM_GEN):\\n for i in range(NUM_LIN):\\n lineages[i] = lineages[i].next_generation()\\n lineages[i].natural_selection()\\n\\n # Control group of survival percentage\\n population = deepcopy(lineages[i])\\n offspring = population.next_generation(num=NUM_HYB)\\n offspring.natural_selection()\\n ctrl[t, i] = [t+1, offspring.survival_rate()]\\n\\n # Hybrids\\n for j in range(NUM_CRS):\\n idx_1, idx_2 = sample(range(len(lineages)), 2)\\n lin_1, lin_2 = deepcopy(lineages[idx_1]), deepcopy(lineages[idx_2])\\n hybrids = lin_1.hybrids(lin_2, num=NUM_HYB, env=ENVIRONMENT)\\n hybrids.natural_selection()\\n\\n # Survival percentage\\n surv[t, j] = [t+1, hybrids.survival_rate()]\\n\\n # Order of incompatibilities\\n counting = {_ord: 0 for _ord in range(1, NUM_G)}\\n inviable = [hybrids.members[i]\\\\\\n for i, survived in enumerate(hybrids.survival)\\\\\\n if not survived]\\n for indv in inviable:\\n for l, n in indv.incompatibility(**ENVIRONMENT).items():\\n counting[l-1] += n\\n order[t, j] = [t+1] + [counting[_ord]/float(NUM_HYB)\\\\\\n for _ord in range(1, NUM_G)]\\n\\n if worker == 0:\\n logging.info('Generation {} is done.'.format(t+1))\\n\\n return (surv.reshape((NUM_GEN*NUM_CRS, 2)).tolist(),\\\\\\n # order.reshape((NUM_GEN*NUM_CRS, NUM_G)).tolist(),\\\\\\n ctrl.reshape((NUM_GEN*NUM_LIN, 2)).tolist())\",\n \"def split_dataset(df_playlists, df_interactions):\\n df_train_pl, cat_pids = generate_train(df_playlists)\\n df_test_pl, df_test_itr, df_eval_itr, df_train_itr = generate_test(cat_pids, df_playlists, df_interactions)\\n\\n return df_train_pl, df_train_itr, df_test_pl, df_test_itr, df_eval_itr\",\n \"def tenpar_subset_test():\\n model_d = \\\"ies_10par_xsec\\\"\\n test_d = os.path.join(model_d, \\\"master_subset_test\\\")\\n template_d = os.path.join(model_d, \\\"test_template\\\")\\n if not os.path.exists(template_d):\\n raise Exception(\\\"template_d {0} not found\\\".format(template_d))\\n if os.path.exists(test_d):\\n shutil.rmtree(test_d)\\n # shutil.copytree(base_d,test_d)\\n pst = pyemu.Pst(os.path.join(template_d, \\\"pest.pst\\\"))\\n pst.control_data.noptmax = 3\\n\\n # first without subset\\n pst.pestpp_options = {}\\n pst.pestpp_options[\\\"ies_num_reals\\\"] = 50\\n pst.pestpp_options[\\\"ies_lambda_mults\\\"] = \\\"1.0\\\"\\n pst.pestpp_options[\\\"ies_accept_phi_fac\\\"] = 100.0\\n pst.write(os.path.join(template_d, \\\"pest.pst\\\"))\\n pyemu.helpers.start_slaves(template_d, exe_path, \\\"pest.pst\\\", num_slaves=10,\\n slave_root=model_d, master_dir=test_d)\\n df_base = pd.read_csv(os.path.join(test_d, \\\"pest.phi.meas.csv\\\"),index_col=0)\\n\\n pst.pestpp_options = {}\\n pst.pestpp_options[\\\"ies_num_reals\\\"] = 50\\n pst.pestpp_options[\\\"ies_lambda_mults\\\"] = \\\"1.0\\\"\\n pst.pestpp_options[\\\"ies_subset_size\\\"] = 15\\n pst.pestpp_options[\\\"ies_accept_phi_fac\\\"] = 100.0\\n\\n pst.write(os.path.join(template_d, \\\"pest.pst\\\"))\\n pyemu.helpers.start_slaves(template_d, exe_path, \\\"pest.pst\\\", num_slaves=10,\\n slave_root=model_d, master_dir=test_d)\\n df_sub = pd.read_csv(os.path.join(test_d, \\\"pest.phi.meas.csv\\\"),index_col=0)\\n diff = (df_sub - df_base).apply(np.abs)\\n print(diff.max())\\n print(df_sub.iloc[-1,:])\\n print(df_base.iloc[-1,:])\\n assert diff.max().max() == 0.0\",\n \"def _subsample(self, hidden, explore, search_space, names, representations, output, description, outer_i=None):\\n name = search_space.name\\n names = copy.deepcopy(names)\\n names.append(name)\\n # Those checks were introduced to reuse this method to evaluate model output for already existing description.\\n if description.get(name) is None:\\n description[name] = {}\\n\\n # region num inner prediction\\n num_inner = self.search_space.eval_(search_space.num_inner, **locals())\\n\\n # region forcing facilitation\\n if description.get(f'num_{name}') is None:\\n forced_inner = self.search_space.eval_(search_space.forced_num_inner, **locals())\\n max_available = max(num_inner) if isinstance(num_inner, (list, tuple)) else num_inner\\n assert forced_inner is None or isinstance(forced_inner, int) and 0 < forced_inner <= max_available\\n\\n if forced_inner is not None:\\n try: forced_inner = num_inner.index(forced_inner)\\n except ValueError:\\n raise ValueError(f'Number of inner search spaces \\\"{forced_inner}\\\" '\\n 'is not present in original search space.')\\n else:\\n forced_inner = num_inner.index(description[f'num_{name}'])\\n # endregion\\n\\n index = self.embedding_index[f'{name}_start']\\n index = wrap([index], self.device, dtype=torch.long)\\n input = self.embedding(index)\\n\\n if len(num_inner) > 1:\\n key = f'{\\\"_\\\".join(names[:-1])}_{len(num_inner)}_{name}s'\\n action, hidden = self.act(input, hidden, explore, key, output, forced_inner)\\n num_inner = num_inner[action.item()]\\n else:\\n hidden = self(input, hidden)\\n num_inner = num_inner[forced_inner] if forced_inner is not None else num_inner[0]\\n\\n if description.get(f'num_{name}') is None:\\n description[f'num_{name}'] = num_inner\\n # endregion\\n\\n # region inner space prediction\\n index = self.embedding_index[f'{num_inner}_{name}s']\\n index = wrap([index], self.device, dtype=torch.long)\\n input = self.embedding(index)\\n\\n encoded_flag = False\\n for i in range(int(num_inner)):\\n if description[name].get(i) is None:\\n description[name][i] = {}\\n\\n if isinstance(search_space.inner, dict):\\n for k, v in search_space.inner.items():\\n v = self.search_space.eval_(v, **locals())\\n key = f'{\\\"_\\\".join(names[:-1])}_{len(v)}_{k}s'\\n\\n if isinstance(v, (list, tuple)) and len(v) > 1:\\n pick = description[name][i].get(k)\\n if pick is not None:\\n try: pick = v.index(pick)\\n except ValueError:\\n raise ValueError(f'Point \\\"{pick}\\\" is not present in '\\n f'{k} dimension of the search space.')\\n\\n action, hidden = self.act(input, hidden, explore, key, output, pick)\\n\\n choice = v[action.item()]\\n\\n if pick is None: description[name][i][k] = choice\\n else: assert choice == description[name][i][k]\\n\\n if k == 'id':\\n if choice in representations:\\n input = representations[choice]\\n continue\\n\\n index = self.embedding_index[f'{k}_{choice}']\\n index = wrap([index], self.device, dtype=torch.long)\\n input = self.embedding(index)\\n else:\\n if description[name][i].get(k) is None:\\n description[name][i][k] = v[0]\\n else: assert v[0] == description[name][i][k]\\n\\n else:\\n assert isinstance(search_space.inner, (list, tuple, SearchSpace)), \\\\\\n 'Inner search space must be either dict, SearchSpace or list of SearchSpaces.'\\n\\n if not encoded_flag:\\n hidden = self(input, hidden)\\n encoded_flag = True\\n\\n spaces = [search_space.inner] if isinstance(search_space.inner, SearchSpace) else search_space.inner\\n for space in spaces:\\n input = self._subsample(hidden, explore, space, names, representations,\\n output, description[name][i], i)\\n hidden = self(input[-1][0], hidden)\\n\\n index = self.embedding_index[f'{name}_inner_done']\\n index = wrap([index], self.device, dtype=torch.long)\\n input = self.embedding(index)\\n # endregion\\n\\n # region outer keys prediction\\n for k, v in search_space.outer.items():\\n v = self.search_space.eval_(v, **locals())\\n key = f'{\\\"_\\\".join(names[:-1])}_{len(v)}_{k}s'\\n\\n if isinstance(v, (list, tuple)) and len(v) > 1:\\n pick = description.get(k)\\n if pick is not None:\\n try: pick = v.index(pick)\\n except ValueError:\\n raise ValueError(f'Point \\\"{pick}\\\" is not present in '\\n f'{k} dimension of the search space.')\\n\\n action, hidden = self.act(input, hidden, explore, key, output, pick)\\n\\n choice = v[action.item()]\\n\\n if pick is None: description[k] = choice\\n else: assert choice == description[k]\\n\\n if k == 'id':\\n if choice in representations:\\n input = representations[choice]\\n continue\\n\\n index = self.embedding_index[f'{k}_{choice}']\\n index = wrap([index], self.device, dtype=torch.long)\\n input = self.embedding(index)\\n else:\\n if description[name][i].get(k) is None:\\n description[name][i][k] = v[0]\\n else: assert v[0] == description[name][i][k]\\n # endregion\\n\\n index = self.embedding_index[f'{name}_end']\\n index = wrap([index], self.device, dtype=torch.long)\\n input = self.embedding(index)\\n\\n hidden = self(input, hidden)\\n if len(names) > 2:\\n repr_key = f'{names[-2]}' if outer_i is None else f'{names[-2]}_{outer_i}'\\n representations[repr_key] = hidden[-1][0]\\n return hidden\",\n \"def split(self, train_fraction=0.8, val_fraction=0.2, test_fraction=0, seed=1):\\n if self.is_initialized():\\n return\\n self.ensure_fraction_sum(train_fraction, val_fraction, test_fraction)\\n np.random.seed(seed)\\n self.samples = sorted(self.samples)\\n np.random.shuffle(self.samples)\\n train_idx = ceil(train_fraction*(len(self.samples)))\\n val_idx = train_idx + ceil(val_fraction*(len(self.samples)))\\n test_idx = val_idx + ceil(test_fraction*(len(self.samples)))\\n indices = list(range(len(self.samples)))\\n self.indices[TRAIN_SUBSET] = indices[:train_idx]\\n self.indices[VAL_SUBSET] = indices[train_idx:val_idx]\\n self.indices[TEST_SUBSET] = indices[val_idx:test_idx]\",\n \"def createSubListOfSpeciesFeatures(self):\\n return _libsbml.MultiSpeciesPlugin_createSubListOfSpeciesFeatures(self)\",\n \"def test_metabolite_production(submodel, reaction_bounds, pseudo_reactions=None, \\n test_producibles=None, test_recyclables=None):\\n if test_producibles:\\n reactants = test_producibles\\n else: \\n reactants = []\\n for reaction in submodel.dfba_obj.expression.reactions:\\n for reactant in reaction.get_reactants():\\n if reactant.id not in reactants:\\n reactants.append(reactant.id)\\n \\n if test_recyclables:\\n products = test_recyclables\\n else: \\n products = []\\n for reaction in submodel.dfba_obj.expression.reactions:\\n for product in reaction.get_products():\\n if product.id not in products:\\n products.append(product.id)\\n\\n if pseudo_reactions:\\n excluded_rxns = pseudo_reactions\\n else:\\n excluded_rxns = [] \\n\\n conv_model = conv_opt.Model(name='model')\\n conv_variables = {}\\n conv_metabolite_matrices = collections.defaultdict(list)\\n for reaction in submodel.reactions:\\n if reaction.id not in excluded_rxns:\\n conv_variables[reaction.id] = conv_opt.Variable(\\n name=reaction.id, type=conv_opt.VariableType.continuous,\\n lower_bound=reaction_bounds[reaction.id][0], \\n upper_bound=reaction_bounds[reaction.id][1])\\n conv_model.variables.append(conv_variables[reaction.id])\\n for part in reaction.participants:\\n conv_metabolite_matrices[part.species.id].append(\\n conv_opt.LinearTerm(conv_variables[reaction.id], \\n part.coefficient)) \\n\\n for met_id, expression in conv_metabolite_matrices.items():\\n conv_model.constraints.append(conv_opt.Constraint(expression, name=met_id, \\n upper_bound=0.0, lower_bound=0.0)) \\n \\n obj_reactants = {}\\n for reactant in reactants: \\n obj_reaction = conv_opt.Variable(name=reactant + '_test_reaction', \\n type=conv_opt.VariableType.continuous,\\n lower_bound=0.0)\\n obj_reactants[reactant] = obj_reaction\\n conv_model.variables.append(obj_reaction)\\n expression = [i for i in conv_model.constraints if i.name==reactant]\\n if expression:\\n expression[0].terms.append(conv_opt.LinearTerm(obj_reaction, -1.))\\n else:\\n conv_model.constraints.append(conv_opt.Constraint(\\n [conv_opt.LinearTerm(obj_reaction, -1.)], name=reactant, \\n upper_bound=0.0, lower_bound=0.0))\\n \\n obj_products = {}\\n for product in products: \\n obj_reaction = conv_opt.Variable(name=product + '_test_reaction', \\n type=conv_opt.VariableType.continuous,\\n lower_bound=0.0)\\n obj_products[product] = obj_reaction\\n conv_model.variables.append(obj_reaction)\\n expression = [i for i in conv_model.constraints if i.name==product]\\n if expression:\\n expression[0].terms.append(conv_opt.LinearTerm(obj_reaction, 1.))\\n else:\\n conv_model.constraints.append(conv_opt.Constraint(\\n [conv_opt.LinearTerm(obj_reaction, 1.)], name=product, \\n upper_bound=0.0, lower_bound=0.0))\\n\\n conv_model.objective_direction = conv_opt.ObjectiveDirection.maximize\\n\\n options = conv_opt.SolveOptions(\\n solver=conv_opt.Solver.cplex,\\n presolve=conv_opt.Presolve.on,\\n solver_options={\\n 'cplex': {\\n 'parameters': {\\n 'emphasis': {\\n 'numerical': 1,\\n },\\n 'read': {\\n 'scale': 1,\\n },\\n },\\n },\\n })\\n\\n unproducibles = []\\n for reactant in reactants:\\n obj_reaction = obj_reactants[reactant]\\n conv_model.objective_terms = [conv_opt.LinearTerm(obj_reaction, 1.),]\\n result = conv_model.solve()\\n if result.value == 0.0:\\n unproducibles.append(reactant)\\n\\n unrecyclables = []\\n for product in products:\\n obj_reaction = obj_products[product]\\n conv_model.objective_terms = [conv_opt.LinearTerm(obj_reaction, 1.),]\\n result = conv_model.solve()\\n if result.value == 0.0:\\n unrecyclables.append(product) \\n\\n return unproducibles, unrecyclables\",\n \"def __getitem__(self, type: str):\\n nodes = pandas.read_csv(join(self.base_path, \\\"nodes.csv\\\"))\\n edges = pandas.read_csv(join(self.base_path, \\\"held.csv\\\"))\\n if type == \\\"link\\\":\\n # nodes = pandas.read_csv(join(self.base_path, \\\"nodes.csv\\\"))\\n held = pandas.read_csv(join(self.base_path, \\\"held.csv\\\"))\\n\\n held = held.query('type == 8')[['src', 'dst']]\\n\\n # node_pool = set(self.splits[2])\\n # held = keep_from_set(held, node_pool)\\n\\n return Experiment(self.embed, nodes, edges, held, split_on=\\\"nodes\\\", neg_sampling_strategy=\\\"word2vec\\\", compact_dst=False)\\n\\n elif type == \\\"apicall\\\":\\n api_seq = pandas.read_csv(self.experiments['apicall'])\\n\\n # unique_nodes = set(nodes['id'].values.tolist())\\n\\n # api_seq_test = api_seq.copy()\\n # api_seq_test['src'] = api_seq_test['src'].apply(lambda nid: nid if nid in unique_nodes else None)\\n # api_seq_test['dst'] = api_seq_test['dst'].apply(lambda nid: nid if nid in unique_nodes else None)\\n # api_seq_test.dropna(axis=0, inplace=True)\\n\\n # disabled for testing\\n # api_seq = api_seq[\\n # api_seq['src'].apply(lambda nid: nid in unique_nodes)\\n # ]\\n #\\n # api_seq = api_seq[\\n # api_seq['dst'].apply(lambda nid: nid in unique_nodes)\\n # ]\\n\\n node_pool = set(self.splits[2])\\n api_seq = keep_from_set(api_seq, node_pool)\\n\\n return Experiment(self.embed, nodes, edges, api_seq, split_on=\\\"nodes\\\", neg_sampling_strategy=\\\"word2vec\\\", compact_dst=False)\\n\\n elif type == \\\"typeuse\\\":\\n held = pandas.read_csv(join(self.base_path, \\\"held.csv\\\"))\\n\\n held = held.query('type == 2')[['src', 'dst']]\\n\\n # node_pool = set(self.splits[2])\\n # held = keep_from_set(held, node_pool)\\n\\n return Experiment(self.embed, nodes, edges, held, split_on=\\\"nodes\\\", neg_sampling_strategy=\\\"word2vec\\\", compact_dst=False)\\n\\n elif type == \\\"varuse\\\":\\n var_use = pandas.read_csv(self.experiments['varuse'])\\n\\n # unique_nodes = set(nodes['id'].values.tolist())\\n node_pool = set(self.splits[2])\\n\\n var_use = var_use[\\n var_use['src'].apply(lambda nid: nid in node_pool)\\n ]\\n\\n return Experiment2(self.embed, nodes, edges, var_use, split_on=\\\"nodes\\\", neg_sampling_strategy=\\\"word2vec\\\")\\n\\n elif type == \\\"fname\\\":\\n\\n # fname = pandas.read_csv(self.experiments['fname'])\\n functions = nodes.query('label == 4096')\\n functions['fname'] = functions['name'].apply(lambda name: name.split(\\\".\\\")[-1])\\n\\n functions['src'] = functions['id']\\n functions['dst'] = functions['fname']\\n\\n # unique_nodes = set(nodes['id'].values.tolist())\\n node_pool = set(self.splits[2])\\n\\n functions = functions[\\n functions['src'].apply(lambda nid: nid in node_pool)\\n ]\\n\\n # use edge splits when outgoing degree is 1\\n\\n return Experiment2(self.embed, nodes, edges, functions[['src', 'dst']], split_on=\\\"edges\\\", neg_sampling_strategy=\\\"word2vec\\\")\\n\\n elif type == \\\"nodetype\\\":\\n\\n types = nodes.copy()\\n types['src'] = nodes['id']\\n types['dst'] = nodes['label']\\n\\n print(\\\"WARNING: Make sure that you target label is stored in the field: label\\\")\\n # raise Warning(\\\"Make sure that you target label is stored in the field: label\\\")\\n\\n node_pool = set(self.splits[2])\\n\\n types['src'] = types['src'].apply(lambda nid: nid if nid in node_pool else None)\\n types = types.dropna(axis=0)\\n\\n return Experiment3(self.embed, nodes, edges, types[['src', 'dst']], split_on=\\\"edges\\\", neg_sampling_strategy=\\\"word2vec\\\")\\n else:\\n raise ValueError(f\\\"Unknown experiment: {type}. The following experiments are available: [apicall|link|typeuse|varuse|fname|nodetype].\\\")\",\n \"def test_processes_per_experiment():\\n # Create a script with 4 experiments.\\n template_script = get_template_script()\\n template_script['experiment1'] = copy.deepcopy(template_script['experiments'])\\n template_script['experiment1']['system'] = utils.CombinatorialLeaf(['explicit-system', 'implicit-system'])\\n # The first two experiments have less number of states than the other two.\\n template_script['experiment1']['protocol'] = 'hydration-protocol'\\n template_script['experiment2'] = copy.deepcopy(template_script['experiments'])\\n template_script['experiment2']['system'] = 'hydration-system'\\n # The last experiment uses SAMS.\\n template_script['experiment2']['sampler'] = utils.CombinatorialLeaf(['repex', 'sams'])\\n template_script['experiments'] = ['experiment1', 'experiment2']\\n\\n exp_builder = ExperimentBuilder(template_script)\\n experiments = list(exp_builder._expand_experiments())\\n\\n # The default is auto.\\n assert exp_builder._options['processes_per_experiment'] == 'auto'\\n\\n # When there is no MPI environment the calculation is serial.\\n assert exp_builder._get_experiment_mpi_group_size(experiments) is None\\n\\n # In an MPI environment, the MPI communicator is split according\\n # to the number of experiments still have to be completed. Each\\n # test case is pair (experiments, MPICOMM size, expected return value).\\n test_cases = [\\n (experiments, 5, 1), # This contains a SAMS sampler so only 1 MPI process is used.\\n (experiments[:-1], 4, [1, 1, 2]), # 3 repex samples, but last experiment has more intermediate states.\\n (experiments[1:-1], 4, [2, 2]), # 2 repex samples on 4 MPI processes.\\n (experiments[1:-1], 6, [3, 3]), # 2 repex samples on 4 MPI processes.\\n (list(reversed(experiments[1:-1])), 3, [2, 1]), # 2 repex samples on 3 MPI processes.\\n (experiments[:-1], 2, 1), # Less MPI processes than experiments, split everything.\\n ]\\n\\n for i, (exp, mpicomm_size, expected_result) in enumerate(test_cases):\\n with mpiplus.mpiplus._simulated_mpi_environment(size=mpicomm_size):\\n result = exp_builder._get_experiment_mpi_group_size(exp)\\n err_msg = ('experiments: {}\\\\nMPICOMM size: {}\\\\nexpected result: {}'\\n '\\\\nresult: {}').format(*test_cases[i], result)\\n assert result == expected_result, err_msg\\n\\n # Test manual setting of processes_per_experiments.\\n test_cases = [2, None]\\n for processes_per_experiment in test_cases:\\n exp_builder._options['processes_per_experiment'] = processes_per_experiment\\n # Serial execution is always None.\\n assert exp_builder._get_experiment_mpi_group_size(experiments) is None\\n with mpiplus.mpiplus._simulated_mpi_environment(size=5):\\n assert exp_builder._get_experiment_mpi_group_size(experiments[:-1]) == processes_per_experiment\\n # When there are SAMS sampler, it's always 1.\\n assert exp_builder._get_experiment_mpi_group_size(experiments) == 1\",\n \"def get_subtechniques_of():\\n global subtechniques_of\\n\\n if not subtechniques_of:\\n subtechniques_of = rsh.subtechniques_of(get_srcs())\\n \\n return subtechniques_of\",\n \"def setup(cls):\\n cls.logger = logging.getLogger('ModelTestLogger')\\n cls.logger.setLevel(logging.DEBUG)\\n\\n s1 = model.Subject('subject1')\\n s2 = model.Subject('subject2')\\n\\n cls.experiment = model.Experiment()\\n cls.experiment.put_subject(s1)\\n cls.experiment.put_subject(s2)\\n\\n setup1 = model.Setup(cls.experiment)\\n modality1 = model.Modality(setup1, 20, 'emg')\\n modality2 = model.Modality(setup1, 5, 'kin')\\n\\n model.Channel(modality1, 'brachoradialis')\\n model.Channel(modality1, 'musculus sterno clavicularis')\\n model.Channel(modality1, 'musculus rhombideus')\\n model.Channel(modality1, 'musculus lattisimus')\\n\\n model.Channel(modality2, 'Pos-X')\\n model.Channel(modality2, 'Pos-Y')\\n model.Channel(modality2, 'Pos-Z')\\n\\n session1 = model.Session(cls.experiment, setup1, s1, 'session1')\\n arr = np.column_stack((\\n np.tile(\\n np.concatenate((\\n np.arange(0., 1., 0.1),\\n np.arange(1., 0., -0.1)\\n )),\\n 10\\n ),\\n np.tile(\\n np.concatenate((\\n np.arange(10),\\n np.arange(10, 0, -1)\\n )),\\n 10\\n ),\\n np.tile(\\n np.concatenate((\\n np.arange(0.0, 0.1, 0.01),\\n np.arange(0.1, 0.0, -0.01)\\n )),\\n 10\\n ),\\n np.tile(\\n np.concatenate((\\n np.arange(0.5, 1.5, 0.1),\\n np.arange(1.5, 0.5, -0.1)\\n )),\\n 10\\n ),\\n ))\\n recording1 = model.Recording(session1, modality1, data=arr,\\n identifier='emg_recording1')\\n\\n arr2 = np.column_stack((\\n np.sum(np.mean(arr.reshape(-1, 4, 4), axis=1), axis=1),\\n np.prod(np.mean(arr.reshape(-1, 4, 4), axis=1), axis=1),\\n np.square(np.sum(np.mean(arr.reshape(-1, 4, 4), axis=1), axis=1))\\n ))\\n recording2 = model.Recording(session1, modality2, data=arr2,\\n identifier='kin_recording1')\\n for i in range(5):\\n model.Trial(recording1, i * 2, 2)\\n model.Trial(recording2, i * 2, 2)\\n\\n session2 = model.Session(cls.experiment, setup1, s2, 'session2')\\n arr = np.add(arr, np.random.randn(*arr.shape))\\n recording1 = model.Recording(session2, modality1, data=arr,\\n identifier='emg_recording2')\\n arr2 = np.column_stack((\\n np.sin(np.mean(np.sum(arr.reshape(-1, 4, 4), axis=1))),\\n np.cos(np.mean(np.sum(arr.reshape(-1, 4, 4), axis=1))),\\n np.tan(np.mean(np.sum(arr.reshape(-1, 4, 4), axis=1)))\\n ))\\n recording2 = model.Recording(session2, modality2, data=arr2,\\n identifier='kin_recording2')\\n for i in range(5):\\n model.Trial(recording1, i * 2, 2)\\n model.Trial(recording2, i * 2, 2)\",\n \"def randomSubData(self, number): \\n if number < 0 or number > self.__numExamples: \\n raise ValueError(\\\"Random subset size must be between 0 and \\\" + str(self.__numExamples))\\n \\n self.__exampleIndices = array(sample(list(range(0, self.__numExamples)), number))\",\n \"def subdivide_mesh(obj, n_subdiv=2):\\n thisfunc = thisfile + '->subdivide_mesh()'\\n\\n scene = bpy.context.scene\\n\\n # All objects need to be in 'OBJECT' mode to apply modifiers -- maybe a Blender bug?\\n for o in bpy.data.objects:\\n scene.objects.active = o\\n bpy.ops.object.mode_set(mode='OBJECT')\\n o.select = False\\n obj.select = True\\n scene.objects.active = obj\\n\\n bpy.ops.object.modifier_add(type='SUBSURF')\\n obj.modifiers['Subsurf'].subdivision_type = 'CATMULL_CLARK'\\n obj.modifiers['Subsurf'].levels = n_subdiv\\n obj.modifiers['Subsurf'].render_levels = n_subdiv\\n\\n # Apply modifier\\n bpy.ops.object.modifier_apply(modifier='Subsurf', apply_as='DATA')\\n\\n # Scene update necessary, as matrix_world is updated lazily\\n scene.update()\\n\\n logging.info(\\\"%s: Subdivided mesh of '%s'\\\", thisfunc, obj.name)\",\n \"def split_dev(self):\\n\\t\\tprint(\\\"Splitting test set into dev and test set\\\")\\n\\n\\t\\told_length = len(self.X[\\\"test\\\"])\\n\\t\\tindices = list(range(old_length))\\n\\n\\t\\tnp.random.seed(0)\\n\\t\\tnp.random.shuffle(indices)\\n\\t\\t\\n\\t\\tsplit = int(len(indices) * 0.5)\\n\\n\\t\\tsplit_indices = {\\\"test\\\": indices[:split], \\\"dev\\\": indices[split:]}\\n\\t\\n\\t\\tfor dataset in (\\\"dev\\\", \\\"test\\\"):\\n\\t\\t\\tself.X[dataset] = [self.X[\\\"test\\\"][idx] for idx in split_indices[dataset]]\\n\\t\\t\\tself.Y[dataset] = [self.Y[\\\"test\\\"][idx] for idx in split_indices[dataset]]\\n\\t\\t\\tself.raw_documents[dataset] = [self.raw_documents[\\\"test\\\"][idx] for idx in split_indices[dataset]]\\n\\t\\t\\tself.tokenized_documents[dataset] = [self.tokenized_documents[\\\"test\\\"][idx] for idx in split_indices[dataset]]\\n\\t\\t\\n\\t\\tprint(\\\"Split test set with\\\", old_length, \\\"samples into\\\", len(self.X[\\\"test\\\"]), \\\"/\\\", len(self.X[\\\"dev\\\"]), \\\"samples\\\")\",\n \"def make_train_devel_test_split(data: Iterable, ratio: str) -> (Iterable, Iterable, Iterable):\\n # Parse the splitting ratio\\n train, devel, test = [int(x) for x in ratio.split(':')]\\n\\n # First split into training+development and test\\n train_devel, _test = train_test_split(data, test_size=(test / (train + devel + test)))\\n # Then split training+development into training and development\\n _train, _devel = train_test_split(train_devel, test_size=(devel / (train + devel)))\\n\\n return _train, _devel, _test\",\n \"def create_four_subplots():\\n pass\",\n \"def get_test_split(self, fraction=0.1):\\n rng = np.random.default_rng(42)\\n test_size = int(round(len(self.all_asset_ids) * fraction))\\n test_ids = rng.choice(self.all_asset_ids, size=test_size, replace=False)\\n train_ids = [i for i in self.all_asset_ids if i not in test_ids]\\n return train_ids, test_ids\",\n \"def build_multiple_datasets(\\n template_dataset='ALLEN_st_cells_1_movies',\\n template_experiment='ALLEN_st_selected_cells_1',\\n model_structs='ALLEN_st_selected_cells_1',\\n this_dataset_name='MULTIALLEN_',\\n cluster=False,\\n print_info=False,\\n N=16):\\n main_config = Allen_Brain_Observatory_Config()\\n\\n # Remove any BP-CC repos in the path\\n bp_cc_paths = [\\n x for x in sys.path if 'contextual' in x or 'Contextual' in x]\\n [sys.path.remove(x) for x in bp_cc_paths]\\n\\n # Append the BP-CC repo to this python path\\n if cluster:\\n cc_path = main_config.cluster_cc_path\\n else:\\n cc_path = main_config.cc_path\\n main_config.cc_data_dir = os.path.join(\\n cc_path,\\n 'dataset_processing') # Pass to encode_datasets.py\\n sys.path.append(cc_path)\\n import experiments # from BP-CC\\n # from db import credentials\\n exps = experiments.experiments()\\n # db_config = credentials.postgresql_connection()\\n\\n # Query all neurons for an experiment setup\\n queries = [ # MICHELE: ADD LOOP HERE\\n [{ # DO THIS SEPARATELY\\n 'rf_coordinate_range': { # Get all cells\\n 'x_min': -10000,\\n 'x_max': 10000,\\n 'y_min': -10000,\\n 'y_max': 10000,\\n },\\n 'structure': 'VISam',\\n 'this_dataset_name': 'MULTIALLEN_VISam'\\n }]\\n ]\\n filter_by_stim = [\\n 'natural_movie_one',\\n 'natural_movie_two'\\n ]\\n sessions = [\\n 'three_session_C',\\n 'three_session_C2'\\n ]\\n print 'Pulling cells by their RFs and stimulus: %s.' % filter_by_stim\\n all_data_dicts = query_neurons_rfs(\\n queries=queries,\\n filter_by_stim=filter_by_stim,\\n sessions=sessions)\\n\\n # Check if a weight sharing is needed\\n assert len(flatten_list(all_data_dicts)) > 0, 'No cells in this query.'\\n\\n # Print cell information if requested\\n if print_info:\\n cre_lines = [x['cre_line'] for x in all_data_dicts[0]]\\n cre_lines, cre_counts = np.unique(cre_lines, return_counts=True)\\n cre_list = [(x, y) for x, y in zip(cre_lines, cre_counts)]\\n print 'Found the following cre line promotors: %s' % json.dumps(\\n cre_list)\\n return\\n\\n # Prepare datasets\\n dataset_method = declare_allen_datasets()[template_dataset]()\\n if dataset_method['weight_sharing']:\\n gridded_rfs, rf_size = create_grid_queries(all_data_dicts[0])\\n if dataset_method['grid_query']:\\n all_data_dicts = query_neurons_rfs(\\n queries=gridded_rfs,\\n filter_by_stim=filter_by_stim,\\n sessions=sessions)\\n all_data_dicts = [\\n x for x in all_data_dicts if x != []] # Filter empties.\\n downsample = dataset_method[\\n 'process_stimuli']['natural_scenes']['resize'][0] /\\\\\\n dataset_method['cc_repo_vars']['model_im_size'][0]\\n filter_size = calculate_rf_size(\\n rf_size=rf_size,\\n downsample=downsample)\\n else:\\n filter_size = None\\n\\n # Declare the experiment template\\n if dataset_method['st_conv']:\\n # Dynamic dataset\\n exp_method_template = os.path.join(\\n main_config.exp_method_template_dir,\\n '3d_exp_method_template.txt')\\n else:\\n # Static dataset\\n exp_method_template = os.path.join(\\n main_config.exp_method_template_dir,\\n '2d_exp_method_template.txt')\\n\\n # Prepare directories\\n model_directory = os.path.join(\\n cc_path,\\n 'models',\\n 'structs')\\n model_templates = glob(\\n os.path.join(\\n model_directory,\\n model_structs,\\n '*.py'))\\n experiment_file = os.path.join(cc_path, 'experiments.py')\\n\\n # Loop through each query and build all possible datasets with template\\n ts = get_dt_stamp()\\n session_name = int(''.join(\\n [random.choice(string.digits) for k in range(N//2)]))\\n for ni, q in enumerate(all_data_dicts):\\n assert len(q), 'Cell dictionary is empty.'\\n meta_dir = os.path.join(\\n main_config.multi_exps,\\n '%s_cells_%s' % (len(q), ts))\\n make_dir(meta_dir)\\n if dataset_method['weight_sharing']:\\n print 'Preparing dataset %s/%s.' % (\\n ni,\\n len(all_data_dicts))\\n rf_grid = rf_extents(q)\\n rf_dict = q[0]\\n rf_dict['on_center_x_max'] = rf_grid['x_max']\\n rf_dict['on_center_y_max'] = rf_grid['y_max']\\n rf_dict['on_center_x'] = rf_grid['x_min']\\n rf_dict['on_center_y'] = rf_grid['y_min']\\n if 'this_dataset_name' in queries[ni][0].keys():\\n this_dataset_name = queries[ni][0]['this_dataset_name']\\n process_dataset(\\n dataset_method=dataset_method,\\n rf_dict=rf_dict,\\n this_dataset_name=this_dataset_name,\\n model_directory=model_directory,\\n model_templates=model_templates,\\n exps=exps,\\n template_experiment=template_experiment,\\n session_name=session_name,\\n meta_dir=meta_dir,\\n db_config=credentials, # db_config,\\n experiment_file=experiment_file,\\n main_config=main_config,\\n idx=ni,\\n cluster=cluster,\\n filter_size=filter_size,\\n exp_method_template=exp_method_template)\\n else:\\n for idx, rf_dict in enumerate(q):\\n print 'Preparing dataset %s/%s in package %s/%s.' % (\\n idx,\\n len(q),\\n ni,\\n len(all_data_dicts))\\n process_dataset(\\n dataset_method=dataset_method,\\n rf_dict=rf_dict,\\n this_dataset_name=this_dataset_name,\\n model_directory=model_directory,\\n model_templates=model_templates,\\n exps=exps,\\n template_experiment=template_experiment,\\n session_name=session_name,\\n meta_dir=meta_dir,\\n db_config=credentials, # db_config,\\n experiment_file=experiment_file,\\n main_config=main_config,\\n idx=idx,\\n cluster=cluster,\\n exp_method_template=exp_method_template)\",\n \"def create_samples_from_api(self, experiment: Experiment, platform_dict: Dict) -> List[Sample]:\\n\\n created_samples = []\\n\\n samples_endpoint = SAMPLES_URL.format(experiment.accession_code)\\n r = utils.requests_retry_session().get(samples_endpoint, timeout=60)\\n samples = r.json()[\\\"experiment\\\"][\\\"sample\\\"]\\n\\n # The SDRF is the complete metadata record on a sample/property basis.\\n # We run this through our harmonizer and then attach the properties\\n # to our created samples.\\n SDRF_URL_TEMPLATE = \\\"https://www.ebi.ac.uk/arrayexpress/files/{code}/{code}.sdrf.txt\\\"\\n sdrf_url = SDRF_URL_TEMPLATE.format(code=experiment.accession_code)\\n sdrf_samples = harmony.parse_sdrf(sdrf_url)\\n\\n title_field = harmony.determine_title_field(sdrf_samples, samples)\\n harmonized_samples = harmony.harmonize_all_samples(sdrf_samples, title_field)\\n\\n # An experiment can have many samples\\n for sample_data in samples:\\n\\n # For some reason, this sample has no files associated with it.\\n if \\\"file\\\" not in sample_data or len(sample_data[\\\"file\\\"]) == 0:\\n continue\\n\\n # Each sample is given an experimenatlly-unique title.\\n flat_sample = utils.flatten(sample_data)\\n title = harmony.extract_title(flat_sample, title_field)\\n\\n # A sample may actually have many sub files.\\n # If there is raw data, take that.\\n # If not, take the derived.\\n has_raw = False\\n for sub_file in sample_data[\\\"file\\\"]:\\n\\n # For ex: E-GEOD-15645\\n if isinstance(sub_file[\\\"comment\\\"], list):\\n sub_file_mod = sub_file\\n sub_file_mod[\\\"comment\\\"] = sub_file[\\\"comment\\\"][0]\\n else:\\n sub_file_mod = sub_file\\n\\n # Some have the 'data' field, but not the actual data\\n # Ex: E-GEOD-9656\\n if (\\n sub_file_mod[\\\"type\\\"] == \\\"data\\\"\\n and sub_file_mod[\\\"comment\\\"].get(\\\"value\\\", None) != None\\n ):\\n has_raw = True\\n\\n # 'value' can be None, convert to an empty string to\\n # make it easier to use.\\n comment_value = sub_file_mod[\\\"comment\\\"].get(\\\"value\\\", \\\"\\\") or \\\"\\\"\\n if \\\"raw\\\" in comment_value:\\n has_raw = True\\n\\n skip_sample = False\\n for sub_file in sample_data[\\\"file\\\"]:\\n\\n # Don't get the raw data if it's only a 1-color sample.\\n if \\\"Cy3\\\" in str(sample_data) and \\\"Cy5\\\" not in str(sample_data):\\n has_raw = False\\n\\n # Skip derived data if we have it raw.\\n if has_raw and \\\"derived data\\\" in sub_file[\\\"type\\\"]:\\n continue\\n\\n download_url = None\\n filename = sub_file[\\\"name\\\"]\\n\\n # sub_file[\\\"comment\\\"] is only a list if there's\\n # more than one comment...\\n comments = sub_file[\\\"comment\\\"]\\n if isinstance(comments, list):\\n # Could be: \\\"Derived ArrayExpress Data Matrix FTP\\n # file\\\" or: \\\"ArrayExpress FTP file\\\". If there is\\n # no comment with a name including \\\"FTP file\\\" then\\n # we don't know where to download it so we need to\\n # mark this job as an error. Therefore don't catch\\n # the potential exception where download_url\\n # doesn't get defined.\\n for comment in comments:\\n if \\\"FTP file\\\" in comment[\\\"name\\\"]:\\n download_url = comment[\\\"value\\\"]\\n break\\n else:\\n download_url = comments[\\\"value\\\"]\\n\\n if not download_url:\\n logger.error(\\n \\\"Sample %s did not specify a download url, skipping.\\\",\\n sample_accession_code,\\n experiment_accession_code=experiment.accession_code,\\n survey_job=self.survey_job.id,\\n sub_file=sub_file,\\n )\\n skip_sample = True\\n continue\\n\\n if not filename:\\n logger.error(\\n \\\"Sample %s did not specify a filename, skipping.\\\",\\n sample_accession_code,\\n experiment_accession_code=experiment.accession_code,\\n survey_job=self.survey_job.id,\\n sub_file=sub_file,\\n )\\n skip_sample = True\\n continue\\n\\n if skip_sample:\\n continue\\n\\n # The accession code is not a simple matter to determine.\\n sample_source_name = sample_data[\\\"source\\\"].get(\\\"name\\\", \\\"\\\")\\n sample_assay_name = sample_data[\\\"assay\\\"].get(\\\"name\\\", \\\"\\\")\\n sample_accession_code = self.determine_sample_accession(\\n experiment.accession_code,\\n sample_source_name,\\n sample_assay_name,\\n filename,\\n )\\n\\n # Figure out the Organism for this sample\\n organism_name = UNKNOWN\\n for characteristic in sample_data[\\\"characteristic\\\"]:\\n if characteristic[\\\"category\\\"].upper() == \\\"ORGANISM\\\":\\n organism_name = characteristic[\\\"value\\\"].upper()\\n\\n if organism_name == UNKNOWN:\\n logger.error(\\n \\\"Sample %s did not specify the organism name.\\\",\\n sample_accession_code,\\n experiment_accession_code=experiment.accession_code,\\n survey_job=self.survey_job.id,\\n )\\n organism = None\\n continue\\n else:\\n organism = Organism.get_object_for_name(organism_name)\\n\\n # Create the sample object\\n try:\\n # Associate it with the experiment, but since it\\n # already exists it already has original files\\n # associated with it and it's already been downloaded,\\n # so don't add it to created_samples.\\n sample_object = Sample.objects.get(accession_code=sample_accession_code)\\n\\n # If input experiment includes new protocol information,\\n # update sample's protocol_info.\\n existing_protocols = sample_object.protocol_info\\n protocol_info, is_updated = self.update_sample_protocol_info(\\n existing_protocols,\\n experiment.protocol_description,\\n experiment.source_url + \\\"/protocols\\\",\\n )\\n if is_updated:\\n sample_object.protocol_info = protocol_info\\n sample_object.save()\\n\\n logger.debug(\\n \\\"Sample %s already exists, skipping object creation.\\\",\\n sample_accession_code,\\n experiment_accession_code=experiment.accession_code,\\n survey_job=self.survey_job.id,\\n )\\n except Sample.DoesNotExist:\\n sample_object = Sample()\\n\\n # The basics\\n sample_object.source_database = \\\"ARRAY_EXPRESS\\\"\\n sample_object.title = title\\n sample_object.accession_code = sample_accession_code\\n sample_object.source_archive_url = samples_endpoint\\n sample_object.organism = organism\\n sample_object.platform_name = platform_dict[\\\"platform_accession_name\\\"]\\n sample_object.platform_accession_code = platform_dict[\\\"platform_accession_code\\\"]\\n sample_object.manufacturer = platform_dict[\\\"manufacturer\\\"]\\n sample_object.technology = \\\"MICROARRAY\\\"\\n\\n protocol_info, is_updated = self.update_sample_protocol_info(\\n existing_protocols=[],\\n experiment_protocol=experiment.protocol_description,\\n protocol_url=experiment.source_url + \\\"/protocols\\\",\\n )\\n # Do not check is_updated the first time because we must\\n # save a list so we can append to it later.\\n sample_object.protocol_info = protocol_info\\n\\n sample_object.save()\\n\\n # Directly assign the harmonized properties\\n harmonized_sample = harmonized_samples[title]\\n ArrayExpressSurveyor._apply_harmonized_metadata_to_sample(\\n sample_object, harmonized_sample\\n )\\n\\n sample_annotation = SampleAnnotation()\\n sample_annotation.name = \\\"raw_metadata\\\"\\n sample_annotation.data = sample_data\\n sample_annotation.sample = sample_object\\n sample_annotation.is_ccdl = False\\n sample_annotation.save()\\n\\n original_file = OriginalFile()\\n original_file.filename = filename\\n original_file.source_filename = filename\\n original_file.source_url = download_url\\n original_file.is_downloaded = False\\n original_file.is_archive = True\\n original_file.has_raw = has_raw\\n original_file.save()\\n\\n original_file_sample_association = OriginalFileSampleAssociation()\\n original_file_sample_association.original_file = original_file\\n original_file_sample_association.sample = sample_object\\n original_file_sample_association.save()\\n\\n created_samples.append(sample_object)\\n\\n logger.debug(\\n \\\"Created \\\" + str(sample_object),\\n experiment_accession_code=experiment.accession_code,\\n survey_job=self.survey_job.id,\\n sample=sample_object.id,\\n )\\n\\n # Create associations if they don't already exist\\n ExperimentSampleAssociation.objects.get_or_create(\\n experiment=experiment, sample=sample_object\\n )\\n\\n ExperimentOrganismAssociation.objects.get_or_create(\\n experiment=experiment, organism=organism\\n )\\n\\n return created_samples\",\n \"def divide_data(n_reconstructions, ratio = [.8,.1,.1], test_set = True, random = False):\\r\\n\\r\\n\\tassert np.sum(ratio) == 1.\\r\\n\\r\\n\\tif test_set:\\r\\n\\t\\tassert len(ratio) == 3\\r\\n\\r\\n\\telse:\\r\\n\\t\\tassert len(ratio) == 2\\r\\n\\t\\t\\t\\r\\n\\tif random:\\r\\n\\t\\tnp.random.seed(0)\\r\\n\\r\\n\\t\\tr = np.arange(n_reconstructions)\\r\\n\\t\\tnp.random.shuffle(r)\\r\\n\\r\\n\\t\\ti_train = r[:int(ratio[0]*n_reconstructions)]\\r\\n\\t\\ti_valid = r[int(ratio[0]*n_reconstructions):int((ratio[0]+ratio[1])*n_reconstructions)]\\r\\n\\r\\n\\t\\tif test_set:\\r\\n\\t\\t\\ti_test = r[int((ratio[0]+ratio[1])*n_reconstructions):]\\r\\n\\r\\n\\telse :\\r\\n\\t\\tr = np.arange(n_reconstructions)\\r\\n\\t\\ti_valid = r[(r+1) % int(ratio[1]*100) == 0]\\r\\n\\r\\n\\t\\tif test_set:\\r\\n\\t\\t\\ti_test = r[(r+2) % int(ratio[2]*100) == 0]\\r\\n\\t\\t\\ti_train = r[((r+1) % int(ratio[1]*100) != 0)*((r+2) % int(ratio[2]*100) != 0)]\\r\\n\\t\\t\\r\\n\\t\\telse:\\r\\n\\t\\t\\ti_train = r[(r+1) % int(ratio[1]*100) != 0]\\r\\n\\r\\n\\tif not(test_set):\\r\\n\\t\\ti_test = []\\r\\n\\r\\n\\treturn i_train,i_valid,i_test\",\n \"def test_documentation_popxl_create_multi_subgraph(self):\\n filename = \\\"create_multi_graphs_from_same_func.py\\\"\\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)\",\n \"def create_materials(endpoint):\\n for phenotype in get_phenotypes(endpoint):\\n print(phenotype)\\n # for now, creating the sample name combining studyDbId and potDbId -\\n # eventually this should be observationUnitDbId\\n sample_name = phenotype['studyDbId']+\\\"_\\\"+phenotype['plotNumber']\\n this_sample = Sample(name=sample_name)\\n that_source = Source(phenotype['germplasmName'], phenotype['germplasmDbId'])\\n this_sample.derives_from = that_source\",\n \"def make(self):\\n numberOfGroups = np.random.randint(1, len(self.getFirstParent().getGroups()))\\n secParentGroups = np.random.choice(self.secondParent.getGroups(), numberOfGroups, replace=False)\\n groups = []\\n allSecElements = []\\n numberOfElements = 0\\n\\n for grpSec in secParentGroups:\\n allSecElements += grpSec.getElements()\\n\\n for grpFst in self.getFirstParent().getGroups():\\n numberOfElements += len(grpFst.getElements())\\n elements = list(set(grpFst.getElements()) - set(allSecElements))\\n group = Group(grpFst.getIndex(), grpFst.getMinElements(), grpFst.getMaxElements())\\n group.setElements(elements)\\n groups.append(group)\\n\\n for grpSec in secParentGroups:\\n for grpFst in groups:\\n if grpSec.getIndex() == grpFst.getIndex():\\n grpFst.addElements(grpSec.getElements())\\n\\n child = Individual(np.zeros(numberOfElements))\\n child.setGroups(groups)\\n\\n return child\",\n \"def three_experiments_with_trials(family_with_trials, single_with_trials):\",\n \"def disaggregate_chunk(self, test_mains):\\n raise NotImplementedError()\",\n \"def regular_subsample(neuron):\\n # select all the main points\\n selected_index = get_main_points(neuorn)\\n\\n # Computing the parent id of the selected nodes\\n neuron = neuron_with_selected_nodes(selected_index)\\n return neuron\",\n \"def __init__(self, pattern_type, experimental_scenario, pattern):\\n self.pattern_type = pattern_type # if pattern_type=1 --> experimental group, otherwise control group\\n self.experimental_scenario = experimental_scenario\\n self.pattern = pattern\",\n \"def testA_FileSplitting(self):\\n splitter = SplitterFactory()\\n\\n oneSetSubscription = self.createSubscription(nFiles=10, lumisPerFile=1)\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\", subscription=oneSetSubscription)\\n\\n jobGroups = jobFactory(lumis_per_job=3, halt_job_on_file_boundaries=True, performance=self.performanceParams)\\n self.assertEqual(len(jobGroups), 1)\\n self.assertEqual(len(jobGroups[0].jobs), 10)\\n for job in jobGroups[0].jobs:\\n self.assertTrue(len(job['input_files']), 1)\\n self.assertEqual(job['estimatedJobTime'], 100 * 12)\\n self.assertEqual(job['estimatedDiskUsage'], 100 * 400)\\n self.assertEqual(job['estimatedMemoryUsage'], 2300)\\n\\n twoLumiFiles = self.createSubscription(nFiles=5, lumisPerFile=2)\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\", subscription=twoLumiFiles)\\n jobGroups = jobFactory(lumis_per_job=1, halt_job_on_file_boundaries=True, performance=self.performanceParams)\\n self.assertEqual(len(jobGroups), 1)\\n self.assertEqual(len(jobGroups[0].jobs), 10)\\n for job in jobGroups[0].jobs:\\n self.assertEqual(len(job['input_files']), 1)\\n self.assertEqual(job['estimatedJobTime'], 50 * 12)\\n self.assertEqual(job['estimatedDiskUsage'], 50 * 400)\\n self.assertEqual(job['estimatedMemoryUsage'], 2300)\\n\\n wholeLumiFiles = self.createSubscription(nFiles=5, lumisPerFile=3)\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\", subscription=wholeLumiFiles)\\n jobGroups = jobFactory(lumis_per_job=2, halt_job_on_file_boundaries=True, performance=self.performanceParams)\\n self.assertEqual(len(jobGroups), 1)\\n # 10 because we split on run boundaries\\n self.assertEqual(len(jobGroups[0].jobs), 10)\\n jobList = jobGroups[0].jobs\\n for idx, job in enumerate(jobList, start=1):\\n # Have should have one file, half two\\n self.assertEqual(len(job['input_files']), 1)\\n if idx % 2 == 0:\\n self.assertEqual(job['estimatedJobTime'], (1.0 * round(100 / 3)) * 12)\\n self.assertEqual(job['estimatedDiskUsage'], (1.0 * round(100 / 3)) * 400)\\n else:\\n self.assertEqual(job['estimatedJobTime'], (2.0 * round(100 / 3)) * 12)\\n self.assertEqual(job['estimatedDiskUsage'], (2.0 * round(100 / 3)) * 400)\\n self.assertEqual(job['estimatedMemoryUsage'], 2300)\\n\\n mask0 = jobList[0]['mask'].getRunAndLumis()\\n self.assertEqual(mask0, {0: [[0, 1]]})\\n mask1 = jobList[1]['mask'].getRunAndLumis()\\n self.assertEqual(mask1, {0: [[2, 2]]})\\n mask2 = jobList[2]['mask'].getRunAndLumis()\\n self.assertEqual(mask2, {1: [[100, 101]]})\\n mask3 = jobList[3]['mask'].getRunAndLumis()\\n self.assertEqual(mask3, {1: [[102, 102]]})\\n\\n j0 = Job(id=jobList[0]['id'])\\n j0.loadData()\\n self.assertEqual(j0['mask'].getRunAndLumis(), {0: [[0, 1]]})\\n\\n # Do it with multiple sites\\n twoSiteSubscription = self.createSubscription(nFiles=5, lumisPerFile=2, twoSites=True)\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\",\\n subscription=twoSiteSubscription)\\n jobGroups = jobFactory(lumis_per_job=1,\\n halt_job_on_file_boundaries=True,\\n performance=self.performanceParams)\\n self.assertEqual(len(jobGroups), 2)\\n self.assertEqual(len(jobGroups[0].jobs), 10)\\n for job in jobGroups[0].jobs:\\n self.assertEqual(len(job['input_files']), 1)\\n self.assertEqual(job['estimatedJobTime'], 50 * 12)\\n self.assertEqual(job['estimatedDiskUsage'], 50 * 400)\\n self.assertEqual(job['estimatedMemoryUsage'], 2300)\",\n \"def make_sub(self, sub):\\n [lu, subs] = [self.lineup, self.subs]\\n if 'PositionSwitch' in str(type(sub)):\\n done = False\\n for player in lu:\\n if player.id == sub.player:\\n done = True\\n player.switch.append(player.pos)\\n player.pos = sub.pos\\n if sub.pos in player.switch:\\n player.switch.remove(sub.pos)\\n if not done:\\n sub_idx = find_player_index(subs, sub.player)\\n if sub.pos == 'p':\\n subs[sub_idx].status = 'entered'\\n if not len([s for s in lu if s.pos == 'p']) > 0:\\n subs[sub_idx].order = 10\\n lu.append(subs.pop(sub_idx))\\n else:\\n print(\\\"ERROR: NOT SURE WHAT TO DO WITH SUB\\\")\\n print([p.__dict__ for p in lu])\\n print(sub.__dict__)\\n\\n elif 'OffensiveSub' in str(type(sub)):\\n lu_idx = find_player_index(lu, sub.sub)\\n sub_idx = find_player_index(subs, sub.player)\\n if sub_idx is None:\\n print(\\\"ERROR: \\\" + str(sub.__dict__))\\n else:\\n if subs[sub_idx].status == 'removed':\\n print('ILLEGAL SUB ' + str(subs[sub_idx].__dict__))\\n if not lu_idx is None:\\n lu[lu_idx].status = 'removed'\\n subs.append(lu.pop(lu_idx))\\n lu.insert(lu_idx, subs.pop(sub_idx))\\n\\n elif 'DefensiveSub' in str(type(sub)):\\n lu_idx = find_player_index(lu, sub.sub)\\n sub_idx = find_player_index(subs, sub.player)\\n if sub_idx is None:\\n if sub.pos == 'p':\\n sub_idx = find_player_index(lu, sub.player)\\n if not sub_idx is None and not lu_idx is None:\\n add = lu[sub_idx]\\n lu[lu_idx].status = 'removed'\\n subs.append(lu.pop(lu_idx))\\n lu.insert(lu_idx, add)\\n if lu[lu_idx].order == 10:\\n lu[lu_idx].order = lu_idx+1\\n else:\\n print(\\\"ERROR: \\\" + str(sub.__dict__))\\n else:\\n if subs[sub_idx].status == 'removed':\\n print('ILLEGAL SUB ' + str(subs[sub_idx].__dict__ ))\\n if not lu_idx is None: \\n lu[lu_idx].status = 'removed'\\n if lu[lu_idx].order != subs[sub_idx].order:\\n print(\\\"ASSUMING ORDER FOR SUB: \\\" + subs[sub_idx].name)\\n subs[sub_idx].order = lu[lu_idx].order\\n for p in lu:\\n if p.pos == subs[sub_idx].pos:\\n p.pos = ''\\n subs.append(lu.pop(lu_idx))\\n lu.insert(lu_idx, subs.pop(sub_idx))\\n\\n elif 'Removal' in str(type(sub)):\\n if lu[-1].id == sub.sub:\\n lu_idx = len(lu)-1\\n else:\\n lu_idx = find_player_index(lu, sub.sub)\\n if not lu_idx is None:\\n lu[lu_idx].status = 'removed'\\n subs.append(lu.pop(lu_idx))\\n \\n\\n [self.lineup, self.subs] = [lu, subs]\",\n \"def __init__(self, specprod_dir=None, **kwargs):\\n if specprod_dir is None:\\n specprod_dir = specprod_root()\\n self.specprod_dir = specprod_dir\\n # Init\\n QA_MultiExp.__init__(self, specprod_dir=specprod_dir, **kwargs)\\n # Load up exposures for the full production\\n nights = get_nights(specprod_dir=self.specprod_dir)\\n for night in nights:\\n self.mexp_dict[night] = {}\\n for exposure in get_exposures(night, specprod_dir = self.specprod_dir):\\n # Object only??\\n frames_dict = get_files(filetype = str('frame'), night = night,\\n expid = exposure, specprod_dir = self.specprod_dir)\\n self.mexp_dict[night][exposure] = frames_dict\\n # Output file names\\n self.qaexp_outroot = self.qaprod_dir+'/'+self.prod_name+'_qa'\\n # Nights list\\n self.qa_nights = []\",\n \"def _trainSubdomainROMs(self, templateROM, counter, trainingSet, romGlobalAdjustments):\\n targets = templateROM.target[:]\\n # clear indices from teh training list, since they're independents\\n # TODO assumes pivotParameter is the only subspace being divided\\n pivotID = templateROM.pivotParameterID\\n targets.remove(pivotID)\\n # stash pivot values, since those will break up while training segments\\n # TODO assumes only pivot param\\n if pivotID not in self._indexValues:\\n self._indexValues[pivotID] = trainingSet[pivotID][0]\\n # loop over clusters and train data\\n roms = []\\n for i, subdiv in enumerate(counter):\\n # slicer for data selection\\n picker = slice(subdiv[0], subdiv[-1] + 1)\\n ## TODO we need to be slicing all the data, not just one realization, once we support non-ARMA segmentation.\\n data = dict((var, [copy.deepcopy(trainingSet[var][0][picker])]) for var in trainingSet)\\n # renormalize the pivot if requested, e.g. by shifting values\\n norm = self._divisionPivotShift[pivotID]\\n if norm:\\n if norm == 'zero':\\n # left-shift pivot so subspace starts at 0 each time\\n delta = data[pivotID][0][0]\\n elif norm == 'first':\\n # left-shift so that first entry is equal to pivot's first value (maybe not zero)\\n delta = data[pivotID][0][0] - trainingSet[pivotID][0][0]\\n data[pivotID][0] -= delta\\n # create a new ROM and train it!\\n newROM = copy.deepcopy(templateROM)\\n newROM.name = '{}_seg{}'.format(self._romName, i)\\n newROM.adjustLocalRomSegment(self._romGlobalAdjustments)\\n self.raiseADebug('Training segment', i, picker)\\n newROM.train(data)\\n roms.append(newROM)\\n # format array for future use\\n roms = np.array(roms)\\n return roms\",\n \"def split(complex, ligand_res_name='LIG'):\\n\\n # Set empty molecule containers\\n prot = oechem.OEMol()\\n lig = oechem.OEMol()\\n wat = oechem.OEMol()\\n other = oechem.OEMol()\\n\\n # Define the Filter options before the splitting\\n opt = oechem.OESplitMolComplexOptions()\\n\\n # The protein filter is set to avoid that multiple\\n # chains are separated during the splitting and peptide\\n # molecules are recognized as ligands\\n pf = oechem.OEMolComplexFilterFactory(oechem.OEMolComplexFilterCategory_Protein) \\n peptide = oechem.OEMolComplexFilterFactory(oechem.OEMolComplexFilterCategory_Peptide)\\n protein_filter = oechem.OEOrRoleSet(pf, peptide)\\n opt.SetProteinFilter(protein_filter)\\n \\n # The ligand filter is set to recognize just the ligand\\n lf = oechem.OEMolComplexFilterFactory(oechem.OEMolComplexFilterCategory_Ligand)\\n not_protein_filter = oechem.OENotRoleSet(protein_filter)\\n ligand_filter = oechem.OEAndRoleSet(lf, not_protein_filter)\\n opt.SetLigandFilter(ligand_filter)\\n\\n # The water filter is set to recognize just water molecules\\n wf = oechem.OEMolComplexFilterFactory(oechem.OEMolComplexFilterCategory_Water)\\n opt.SetWaterFilter(wf)\\n\\n # Set Category\\n cat = oechem.OEMolComplexCategorizer()\\n cat.AddLigandName(ligand_res_name)\\n opt.SetCategorizer(cat)\\n\\n # Splitting the system\\n if not oechem.OESplitMolComplex(lig, prot, wat, other, complex, opt):\\n raise ValueError('Unable to split the complex')\\n \\n # At this point prot contains the protein, lig contains the ligand,\\n # wat contains the water and excipients contains the excipients\\n\\n return prot, lig, wat, other\",\n \"def generate_test_instances(self):\\n for testproblem in self.testproblems:\\n for solverconfig in self.solverconfigs:\\n self.instances.append(TestInstance(testproblem, solverconfig))\",\n \"def __init__(self,subWindow,currentExperiment):\\n super(AmoebaCreateExperiment,self).__init__()\\n self.stage = 0\\n self.currentExperiment = currentExperiment\\n #self.XMLWriter = ExperimentXMLWriter()\\n self.XMLWriter = Amoeba_experiment()\\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\\n print \\\"Create new experiment.\\\"\\n\\n self.subWindow = subWindow\\n\\n #Create a scroll bar for the summary area\\n self.layout = QVBoxLayout()\\n\\n #Create the widgets\\n self.SetFundamentalParameters = AmoebaSetFundamentalParameters()\\n self.ShowAllInstruments = AmoebaShowAllInstuments()\\n self.LinkInstruments = LinkInstrumentsForm()\\n\\n self.next = QPushButton(\\\"Next\\\")\\n self.next.clicked.connect(self.next_pressed)\\n\\n #Add to the scroll widget\\n self.layout.addWidget(self.SetFundamentalParameters)\\n self.layout.addWidget(self.ShowAllInstruments)\\n self.layout.addWidget(self.LinkInstruments)\\n self.layout.addWidget(self.next)\\n\\n #Add the Widgets to the Subwindow\\n self.setLayout(self.layout)\\n\\n #Hide all the widgets that will later be revealed.\\n self.SetFundamentalParameters.hide()\\n self.LinkInstruments.hide()\",\n \"def test_construct_subcircuit_layers(self):\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=3)\\r\\n\\r\\n def circuit(params):\\r\\n # section 1\\r\\n qml.RX(params[0], wires=0)\\r\\n # section 2\\r\\n qml.RY(params[1], wires=0)\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.CNOT(wires=[1, 2])\\r\\n # section 3\\r\\n qml.RX(params[2], wires=0)\\r\\n qml.RY(params[3], wires=1)\\r\\n qml.RZ(params[4], wires=2)\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.CNOT(wires=[1, 2])\\r\\n # section 4\\r\\n qml.RX(params[5], wires=0)\\r\\n qml.RY(params[6], wires=1)\\r\\n qml.RZ(params[7], wires=2)\\r\\n qml.CNOT(wires=[0, 1])\\r\\n qml.CNOT(wires=[1, 2])\\r\\n return qml.expval(qml.PauliX(0)), qml.expval(qml.PauliX(1)), qml.expval(qml.PauliX(2))\\r\\n\\r\\n circuit = qml.QNode(circuit, dev)\\r\\n\\r\\n params = np.ones([8])\\r\\n tapes = circuit.metric_tensor(params, only_construct=True)\\r\\n\\r\\n # this circuit should split into 4 independent\\r\\n # sections or layers when constructing subcircuits\\r\\n assert len(tapes) == 4\\r\\n\\r\\n # first layer subcircuit\\r\\n assert len(tapes[0].operations) == 1\\r\\n assert isinstance(tapes[0].operations[0], qml.Hadamard) # PauliX decomp\\r\\n\\r\\n # second layer subcircuit\\r\\n assert len(tapes[1].operations) == 4\\r\\n assert isinstance(tapes[1].operations[0], qml.RX)\\r\\n # PauliY decomp\\r\\n assert isinstance(tapes[1].operations[1], qml.PauliZ)\\r\\n assert isinstance(tapes[1].operations[2], qml.S)\\r\\n assert isinstance(tapes[1].operations[3], qml.Hadamard)\\r\\n\\r\\n # # third layer subcircuit\\r\\n assert len(tapes[2].operations) == 8\\r\\n assert isinstance(tapes[2].operations[0], qml.RX)\\r\\n assert isinstance(tapes[2].operations[1], qml.RY)\\r\\n assert isinstance(tapes[2].operations[2], qml.CNOT)\\r\\n assert isinstance(tapes[2].operations[3], qml.CNOT)\\r\\n # PauliX decomp\\r\\n assert isinstance(tapes[2].operations[4], qml.Hadamard)\\r\\n # PauliY decomp\\r\\n assert isinstance(tapes[2].operations[5], qml.PauliZ)\\r\\n assert isinstance(tapes[2].operations[6], qml.S)\\r\\n assert isinstance(tapes[2].operations[7], qml.Hadamard)\\r\\n\\r\\n # # fourth layer subcircuit\\r\\n assert len(tapes[3].operations) == 13\\r\\n assert isinstance(tapes[3].operations[0], qml.RX)\\r\\n assert isinstance(tapes[3].operations[1], qml.RY)\\r\\n assert isinstance(tapes[3].operations[2], qml.CNOT)\\r\\n assert isinstance(tapes[3].operations[3], qml.CNOT)\\r\\n assert isinstance(tapes[3].operations[4], qml.RX)\\r\\n assert isinstance(tapes[3].operations[5], qml.RY)\\r\\n assert isinstance(tapes[3].operations[6], qml.RZ)\\r\\n assert isinstance(tapes[3].operations[7], qml.CNOT)\\r\\n assert isinstance(tapes[3].operations[8], qml.CNOT)\\r\\n # PauliX decomp\\r\\n assert isinstance(tapes[3].operations[9], qml.Hadamard)\\r\\n # PauliY decomp\\r\\n assert isinstance(tapes[3].operations[10], qml.PauliZ)\\r\\n assert isinstance(tapes[3].operations[11], qml.S)\\r\\n assert isinstance(tapes[3].operations[12], qml.Hadamard)\",\n \"def _exp_splayer(ss) :\\n\\texp_list = ss.experiments\\n\\tfor exp in exp_list : \\n\\t\\tss_copy = copy.copy(ss) # create a copy of original ss\\n\\t\\tss_copy.experiments = [exp]\\n\\t\\tyield ss_copy\",\n \"def exp_main(self, use_remote_data=True, test=False):\\n test = str_to_bool(test)\\n use_remote_data = str_to_bool(use_remote_data)\\n root_uri = get_root_uri(use_remote_data)\\n root_uri = os.path.join(root_uri, rv_output_dir)\\n spacenet_config = VegasBuildings(use_remote_data)\\n experiments = []\\n runs = [0]\\n\\n noise_modes = [\\n NoiseMode(NoiseMode.SHIFT, 0),\\n NoiseMode(NoiseMode.SHIFT, 10),\\n NoiseMode(NoiseMode.SHIFT, 20),\\n NoiseMode(NoiseMode.SHIFT, 30),\\n NoiseMode(NoiseMode.SHIFT, 40),\\n NoiseMode(NoiseMode.SHIFT, 50),\\n NoiseMode(NoiseMode.DROP, 0.0),\\n NoiseMode(NoiseMode.DROP, 0.1),\\n NoiseMode(NoiseMode.DROP, 0.2),\\n NoiseMode(NoiseMode.DROP, 0.3),\\n NoiseMode(NoiseMode.DROP, 0.4),\\n NoiseMode(NoiseMode.DROP, 0.5)\\n ]\\n\\n for nm in noise_modes:\\n for run in runs:\\n exp_id = get_exp_id(nm, run)\\n task = build_task(spacenet_config.get_class_map())\\n backend = build_fastai_backend(task, test)\\n analyzer = rv.AnalyzerConfig.builder(rv.STATS_ANALYZER) \\\\\\n .build()\\n dataset = build_dataset(task, spacenet_config, test, nm)\\n\\n experiment = rv.ExperimentConfig.builder() \\\\\\n .with_id(exp_id) \\\\\\n .with_analyze_key('shift-0-0') \\\\\\n .with_task(task) \\\\\\n .with_backend(backend) \\\\\\n .with_analyzer(analyzer) \\\\\\n .with_dataset(dataset) \\\\\\n .with_root_uri(root_uri) \\\\\\n .build()\\n experiments.append(experiment)\\n\\n return experiments\",\n \"def subdivide(self, subdivision, new_point):\\n\\n\\t\\tassert(subdivision.ndim == 3)\\n\\n\\t\\t# Find the attached faces.\\n\\t\\tface1, face2, face3, face4 = self.attached_faces\\n\\n\\t\\t# Find the attached lines, and be able to associate them with the\\n\\t\\t# faces.\\n\\t\\tline12, = face1.attached_lines & face2.attached_lines\\n\\t\\tline13, = face1.attached_lines & face3.attached_lines\\n\\t\\tline14, = face1.attached_lines & face4.attached_lines\\n\\t\\tline23, = face2.attached_lines & face3.attached_lines\\n\\t\\tline24, = face2.attached_lines & face4.attached_lines\\n\\t\\tline34, = face3.attached_lines & face4.attached_lines\\n\\n\\t\\t# Find the attached points, and be able to associate them with the \\n\\t\\t# faces.\\n\\t\\tpoint123, = line12.attached_points & line13.attached_points\\n\\t\\tpoint124, = line12.attached_points & line14.attached_points\\n\\t\\tpoint134, = line13.attached_points & line14.attached_points\\n\\t\\tpoint234, = line23.attached_points & line24.attached_points\\n\\n\\t\\t# Create the new lines.\\n\\t\\tnew_line123 = matplot3dext.objects.line.Line(point123, new_point)\\n\\t\\tnew_line124 = matplot3dext.objects.line.Line(point124, new_point)\\n\\t\\tnew_line134 = matplot3dext.objects.line.Line(point134, new_point)\\n\\t\\tnew_line234 = matplot3dext.objects.line.Line(point234, new_point)\\n\\n\\t\\t# Create the new faces.\\n\\t\\tnew_face12 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline12, new_line123, new_line124)\\n\\t\\tnew_face13 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline13, new_line123, new_line134)\\n\\t\\tnew_face14 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline14, new_line124, new_line134)\\n\\t\\tnew_face23 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline23, new_line123, new_line234)\\n\\t\\tnew_face24 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline24, new_line124, new_line234)\\n\\t\\tnew_face34 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline34, new_line134, new_line234)\\n\\n\\t\\t# Create the new tetrahedra.\\n\\t\\t#\\n\\t\\t# Make a sketch to understand what's going on now.\\n\\t\\tnew_tetrahedron1 = Tetrahedron(\\n\\t\\t\\t\\tface1, new_face12, new_face13, new_face14)\\n\\t\\tnew_tetrahedron2 = Tetrahedron(\\n\\t\\t\\t\\tface2, new_face12, new_face23, new_face24)\\n\\t\\tnew_tetrahedron3 = Tetrahedron(\\n\\t\\t\\t\\tface3, new_face13, new_face23, new_face34)\\n\\t\\tnew_tetrahedron4 = TetrahedroN(\\n\\t\\t\\t\\tface4, new_face14, new_face24, new_face34)\\n\\n\\t\\tself.replace_by([new_tetrahdron1, new_tetrahedron2, \\n\\t\\t\\t\\tnew_tetrahedron3, new_tetrahedron4], subdivision.world)\\n\\n\\t\\treturn new_point\",\n \"def split(self):\\n\\n ratio_c = 1 - self.ratio\\n self.train, self.test = self.df.randomSplit([self.ratio, ratio_c], seed=12345)\",\n \"def _generate_examples(self, folders, split):\\n raise NotImplementedError(\\\"TODO\\\")\",\n \"def test_split_trajectories():\\n\\n num_trajectories = 100\\n trajectory_timesteps = 100\\n subsequence_length = 10\\n\\n # Generate trajectories\\n trajectories: List[torchfilter.types.TrajectoryNumpy] = []\\n for i in range(num_trajectories):\\n trajectories.append(\\n torchfilter.types.TrajectoryNumpy(\\n states=np.ones((trajectory_timesteps, 5)),\\n observations={\\n \\\"key\\\": np.zeros((trajectory_timesteps, 5)),\\n \\\"some_other_key\\\": np.zeros((trajectory_timesteps, 5)),\\n },\\n controls=np.zeros((trajectory_timesteps, 5)),\\n )\\n )\\n\\n # Split into subsequences\\n subsequences = torchfilter.data.split_trajectories(\\n trajectories, subsequence_length=subsequence_length\\n )\\n\\n # Validate subsequences\\n assert len(subsequences) == num_trajectories * 19\\n for traj in subsequences:\\n assert traj.states.shape == (subsequence_length, 5)\\n assert traj.controls.shape == (subsequence_length, 5)\\n assert np.allclose(traj.states, 1.0)\\n assert \\\"key\\\" in traj.observations\\n assert \\\"some_other_key\\\" in traj.observations\\n assert np.allclose(traj.controls, 0.0)\",\n \"def build_subsets(self):\\n self.all = nrn.SectionList()\\n self.all.wholetree(sec=self.soma)\",\n \"def testGetFromSplits(self):\\n artifacts = [standard_artifacts.Examples()]\\n artifacts[0].uri = '/tmp'\\n artifacts[0].split_names = artifact_utils.encode_split_names(\\n ['train', 'eval'])\\n\\n self.assertEqual(artifacts[0].split_names, '[\\\"train\\\", \\\"eval\\\"]')\\n\\n self.assertIs(artifact_utils.get_single_instance(artifacts), artifacts[0])\\n self.assertEqual('/tmp', artifact_utils.get_single_uri(artifacts))\\n self.assertEqual('/tmp/train',\\n artifact_utils.get_split_uri(artifacts, 'train'))\\n self.assertEqual('/tmp/eval',\\n artifact_utils.get_split_uri(artifacts, 'eval'))\",\n \"def create_subset_list(self):\\n\\n row = 0\\n for time_step in self.min_increments:\\n subset = SubsetClass(time_step=time_step, query_df=self.query_df, model_df=self.model_df, row=row)\\n self.subset_list.append(subset)\\n row += 1\",\n \"def split_data(self, verbose=False):\\n # group sample by patient and body part\\n tmp = self.data_info.groupby(['patientID', 'body_part']).max()\\n # get the index (i.e. patient and bodypart) where none of the body part XR of a given patient are abnormal\\n idx_list_normal = tmp[tmp.body_part_abnormal == 0].index.to_list()\\n # get the index (i.e. patient and bodypart) where at least one but not all of the body part XR of a given patient are abnormal\\n idx_list_mixt = tmp[tmp.body_part_abnormal == 0.5].index.to_list()\\n # get the index (i.e. patient and bodypart) where all one of the body part XR of a given patient are abnormal\\n idx_list_abnormal = tmp[tmp.body_part_abnormal == 1].index.to_list()\\n total = len(idx_list_normal)+len(idx_list_mixt)+len(idx_list_abnormal)\\n train_size = self.train_frac*total\\n assert train_size < len(idx_list_normal), f'There are not enough normal sample for the given train_frac : {self.train_frac}. \\\\\\n There are {len(idx_list_normal)} normal sample over {total} total samples.'\\n valid_size = (1-self.train_frac)*0.5*total\\n test_size = (1-self.train_frac)*0.5*total\\n # randomly pick (1-ratio_known_abnormal)*train_frac*total from the normal index for the train set\\n train_idx_normal, remain = train_test_split(idx_list_normal, \\\\\\n train_size=int((1-self.ratio_known_abnormal)*train_size),\\\\\\n random_state=self.random_state)\\n # split the rest equally in the validation and test set\\n valid_idx_normal, test_idx_normal = train_test_split(remain, test_size=0.5, random_state=self.random_state)\\n # add ratio_known_abnormal*train_frac*total from the abnormal index\\n if self.ratio_known_abnormal == 0.0:\\n train_idx_abnormal, remain = [], idx_list_abnormal\\n else:\\n train_idx_abnormal, remain = train_test_split(idx_list_abnormal, \\\\\\n train_size=int(self.ratio_known_abnormal*train_size),\\\\\\n random_state=self.random_state)\\n # split the rest equally in the validation and test set\\n valid_idx_abnormal, test_idx_abnormal = train_test_split(remain, test_size=0.5, random_state=self.random_state)\\n # split the mixt between test and validation and consider them as abnormal patients bodypart\\n valid_idx_mixt, test_idx_mixt = train_test_split(idx_list_mixt, test_size=0.5, random_state=self.random_state)\\n valid_idx_abnormal += valid_idx_mixt\\n test_idx_abnormal += test_idx_mixt\\n # get the known and unknown index for each sets\\n # get a fraction of normal known\\n if self.ratio_known_normal == 0.0:\\n train_idx_known, train_idx_unknown = [], train_idx_normal\\n valid_idx_known, valid_idx_unknown = [], valid_idx_normal\\n test_idx_known, test_idx_unknown = [], test_idx_normal\\n else:\\n train_idx_known, train_idx_unknown = train_test_split(train_idx_normal, \\\\\\n train_size=int(self.ratio_known_normal*train_size),\\\\\\n random_state=self.random_state)\\n valid_idx_known, valid_idx_unknown = train_test_split(valid_idx_normal, \\\\\\n train_size=int(self.ratio_known_normal*valid_size),\\\\\\n random_state=self.random_state)\\n test_idx_known, test_idx_unknown = train_test_split(test_idx_normal, \\\\\\n train_size=int(self.ratio_known_normal*test_size), \\\\\\n random_state=self.random_state)\\n # get the abnormal known\\n # all abnormal in train are known\\n train_idx_known += train_idx_abnormal\\n if self.ratio_known_abnormal == 0.0:\\n valid_idx_unknown += valid_idx_abnormal\\n test_idx_unknown += test_idx_abnormal\\n else:\\n valid_idx_known_abnormal, valid_idx_unknown_abnormal = train_test_split(valid_idx_abnormal, \\\\\\n train_size=int(self.ratio_known_abnormal*valid_size), \\\\\\n random_state=self.random_state)\\n valid_idx_known += valid_idx_known_abnormal\\n valid_idx_unknown += valid_idx_unknown_abnormal\\n test_idx_known_abnormal, test_idx_unknown_abnormal = train_test_split(test_idx_abnormal, \\\\\\n train_size=int(self.ratio_known_abnormal*test_size),\\\\\\n random_state=self.random_state)\\n test_idx_known += test_idx_known_abnormal\\n test_idx_unknown += test_idx_unknown_abnormal\\n\\n # get the subsample dataframe with semi-label\\n train_df = self.generate_semisupervized_label(train_idx_known, train_idx_unknown)\\n valid_df = self.generate_semisupervized_label(valid_idx_known, valid_idx_unknown)\\n test_df = self.generate_semisupervized_label(test_idx_known, test_idx_unknown)\\n # shuffle the dataframes\\n self.subsets['train'] = train_df.sample(frac=1, random_state=self.random_state).reset_index(drop=True)\\n self.subsets['valid'] = valid_df.sample(frac=1, random_state=self.random_state).reset_index(drop=True)\\n self.subsets['test'] = test_df.sample(frac=1, random_state=self.random_state).reset_index(drop=True)\\n # Print summary\\n if verbose:\\n self.print_stat()\",\n \"def test_partially_one(self):\\n setups = self.get_setup().decompress([\\\"dimensions.species_id\\\"])\\n assert isinstance(setups, PlotSetupGroup)\\n assert all(isinstance(setup, PlotSetup) for setup in setups)\\n assert len(setups) == 2\\n res = {\\n (\\n s.panels.collect_equal(\\\"dimensions\\\").variable,\\n s.panels.collect_equal(\\\"dimensions\\\").species_id,\\n s.panels.collect_equal(\\\"dimensions\\\").time,\\n )\\n for s in setups\\n }\\n sol = {\\n ((\\\"dry_deposition\\\", \\\"wet_deposition\\\"), 1, (1, 2, 3)),\\n ((\\\"dry_deposition\\\", \\\"wet_deposition\\\"), 2, (1, 2, 3)),\\n }\\n assert res == sol\",\n \"def set_up_and_parameterise_model_for_experiment(self):\\n self.experiment_unique_steps_to_model = {}\\n for op_number, op in enumerate(self.experiment.unique_steps):\\n new_model = self.model.new_copy()\\n new_parameter_values = self.parameter_values.copy()\\n\\n if op.type != \\\"current\\\":\\n # Voltage or power control\\n # Create a new model where the current density is now a variable\\n # To do so, we replace all instances of the current density in the\\n # model with a current density variable, which is obtained from the\\n # FunctionControl submodel\\n # check which kind of external circuit model we need (differential\\n # or algebraic)\\n if op.type == \\\"voltage\\\":\\n submodel_class = pybamm.external_circuit.VoltageFunctionControl\\n elif op.type == \\\"power\\\":\\n submodel_class = pybamm.external_circuit.PowerFunctionControl\\n\\n # Build the new submodel and update the model with it\\n submodel = submodel_class(new_model.param, new_model.options)\\n variables = new_model.variables\\n submodel.variables = submodel.get_fundamental_variables()\\n variables.update(submodel.variables)\\n submodel.variables.update(submodel.get_coupled_variables(variables))\\n variables.update(submodel.variables)\\n submodel.set_rhs(variables)\\n submodel.set_algebraic(variables)\\n submodel.set_initial_conditions(variables)\\n new_model.rhs.update(submodel.rhs)\\n new_model.algebraic.update(submodel.algebraic)\\n new_model.initial_conditions.update(submodel.initial_conditions)\\n\\n # Set the \\\"current function\\\" to be the variable defined in the submodel\\n new_parameter_values[\\\"Current function [A]\\\"] = submodel.variables[\\n \\\"Current [A]\\\"\\n ]\\n self.update_new_model_events(new_model, op)\\n # Update parameter values\\n self._original_temperature = new_parameter_values[\\\"Ambient temperature [K]\\\"]\\n experiment_parameter_values = self.get_experiment_parameter_values(\\n op, op_number\\n )\\n new_parameter_values.update(\\n experiment_parameter_values, check_already_exists=False\\n )\\n parameterised_model = new_parameter_values.process_model(\\n new_model, inplace=False\\n )\\n self.experiment_unique_steps_to_model[repr(op)] = parameterised_model\\n\\n # Set up rest model if experiment has start times\\n if self.experiment.initial_start_time:\\n new_model = self.model.new_copy()\\n # Update parameter values\\n new_parameter_values = self.parameter_values.copy()\\n self._original_temperature = new_parameter_values[\\\"Ambient temperature [K]\\\"]\\n new_parameter_values.update(\\n {\\\"Current function [A]\\\": 0, \\\"Ambient temperature [K]\\\": \\\"[input]\\\"},\\n check_already_exists=False,\\n )\\n parameterised_model = new_parameter_values.process_model(\\n new_model, inplace=False\\n )\\n self.experiment_unique_steps_to_model[\\n \\\"Rest for padding\\\"\\n ] = parameterised_model\",\n \"def initialize_substructure_production(self):\\n\\n self.wet_storage = WetStorage(self.env, float(\\\"inf\\\"))\\n takt_time = self.config[\\\"offshore_substation_substructure\\\"].get(\\\"takt_time\\\", 0)\\n attach_time = self.config[\\\"offshore_substation_topside\\\"].get(\\\"attach_time\\\", 24)\\n to_assemble = [1] * self.num_substations\\n\\n self.assembly_line = SubstationAssemblyLine(to_assemble, takt_time, attach_time, self.wet_storage, 1)\\n\\n self.env.register(self.assembly_line)\\n self.assembly_line.start()\",\n \"def create_master(exp, var, data=None, new_fields=[]):\\n\\n if isinstance(var, basestring):\\n assert data is not None\\n data_dict = data\\n new_fields.append(var)\\n else:\\n # see if it's a Var, and access metadata from the associated\\n # Experiment\\n if data is None:\\n data_dict = var.data\\n else:\\n data_dict = data\\n new_fields.append(var.varname)\\n new_fields.extend(var.oldvar)\\n\\n all_case_vals = exp.all_case_vals()\\n\\n # Post-process the case inspection a bit:\\n # 1) Promote any single-value case to a list with one entry\\n for i, case_vals in enumerate(all_case_vals):\\n if isinstance(case_vals, str):\\n all_case_vals[i] = list(case_vals)\\n\\n # 2) Make sure they're all still in the data dictionary. This is\\n # circular but a necessary sanity check\\n for case_bits in product(*all_case_vals):\\n assert case_bits in data_dict\\n\\n # Discover the type of the data passed into this method. If\\n # it's an xarray type, we'll preserve that. If it's an iris type,\\n # then we need to crash for now.\\n first_case = next(exp.all_cases())\\n\\n proto = data_dict[first_case]\\n if isinstance(proto, Dataset):\\n return _master_dataset(exp, data_dict, new_fields)\\n elif isinstance(proto, DataArray):\\n return _master_dataarray(exp, data_dict)\\n # elif isinstance(proto, Cube):\\n # raise NotImplementedError(\\\"Cube handling not yet implemented\\\")\\n else:\\n raise ValueError(\\\"Data must be an xarray type\\\")\",\n \"def read_and_split_sets():\\n gen_train_test_sets(\\\"Data_Sent_Embds/en_sent.pkl\\\", \\\"Data_Sent_Embd_Splitted/en_train.pkl\\\",\\n \\\"Data_Sent_Embd_Splitted/en_test.pkl\\\")\\n gen_train_test_sets(\\\"Data_Sent_Embds/es_sent.pkl\\\", \\\"Data_Sent_Embd_Splitted/es_train.pkl\\\",\\n \\\"Data_Sent_Embd_Splitted/es_test.pkl\\\")\\n gen_train_test_sets(\\\"Data_Sent_Embds/pr_sent.pkl\\\", \\\"Data_Sent_Embd_Splitted/pr_train.pkl\\\",\\n \\\"Data_Sent_Embd_Splitted/pr_test.pkl\\\")\",\n \"def _CreateSubmodel(unused_path):\\n return confusion_matrices.ConfusionMatrices()\",\n \"def subgroup(self, IDs):\\n return Process([getattr(self, i) for i in IDs])\",\n \"def test_split_activities(self):\\n labels = np.ones(3000)\\n labels[range(150)] = 2\\n X = np.ones((3000,9))\\n splittedX, splitted_y = tutorial_pamap2.split_activities(labels,X,[0], borders=50)\\n assert splittedX[0].shape == (50, 9)\\n assert splittedX[1].shape == (2750, 9)\",\n \"def experiments(self, key, value):\\n experiments = self.get('experiments', [])\\n\\n name = value.get('e')\\n recid = value.get('0')\\n record = get_record_ref(recid, 'experiments')\\n\\n experiments.append({\\n 'curated_relation': record is not None,\\n 'name': name,\\n 'record': record\\n })\\n\\n return experiments\",\n \"def _select_and_run_experiment(self, i):\\n ipick = self.model.pick()\\n if ipick in self.model.uu:\\n self.workers[i] = (ipick, 'z')\\n self.model.tz.append(ipick)\\n self.model.b -= self.cz\\n self.finish_time[i] += np.random.uniform(self.cz, self.cz * 2)\\n else:\\n self.workers[i] = (ipick, 'y')\\n self.model.ty.append(ipick)\\n self.model.b -= self.cy\\n self.finish_time[i] += np.random.uniform(self.cy, self.cy * 2)\",\n \"def __init__(self, subplot_objects):\\n self.subplot_objects = subplot_objects\",\n \"def new_experiment_from_components(self, dataset_params, input_params,\\n architecture, model_params,\\n train_params=None,\\n name='', description=''):\\n exp_name = name or ''\\n try:\\n # find each component by id then create the full JSON\\n dataset_params_obj = self.dbclient.find_by_id(\\n ConfigRef.DATASET_PARAMS, dataset_params)\\n dataset_params_cf = dataset_params_obj[RefAttr.CONFIG]\\n\\n input_params_obj = self.dbclient.find_by_id(\\n ConfigRef.INPUT_PARAMS, input_params)\\n input_params_cf = input_params_obj[RefAttr.CONFIG]\\n\\n architecture_obj = self.dbclient.find_by_id(\\n ConfigRef.ARCHITECTURE, architecture)\\n architecture_cf = architecture_obj[RefAttr.CONFIG]\\n\\n model_params_obj = self.dbclient.find_by_id(\\n ConfigRef.MODEL_PARAMS, model_params)\\n model_params_cf = model_params_obj[RefAttr.CONFIG]\\n\\n if train_params:\\n train_params_obj = self.dbclient.find_by_id(\\n ConfigRef.TRAIN_PARAMS, train_params)\\n train_params_cf = train_params_obj[RefAttr.CONFIG]\\n else:\\n train_params_cf = '{ }'\\n\\n config = self._new_config_from_components(\\n dataset_params_cf, input_params_cf, architecture_cf,\\n model_params_cf, train_params_cf\\n )\\n\\n if not name:\\n exp_name = ' - '.join([\\n dataset_params_obj[RefAttr.NAME],\\n input_params_obj[RefAttr.NAME],\\n architecture_obj[RefAttr.NAME],\\n model_params_obj[RefAttr.NAME],\\n train_params_obj[RefAttr.NAME] if train_params else '',\\n ])\\n return self.new_experiment_from_full_config(\\n exp_name, config, description=description)\\n except Exception:\\n return None\",\n \"def create_data_generators(shuffle=True, novelty_type='normal', item_to_include='None',\\n scale_level=1):\\n\\n total_noi_i = 10 # Number of processed images from one environemnt i\\n noe = 1 # Numer of environments\\n n_p = 32 # Patch size, patch --> n_p x n_p\\n\\n novelty = novelty_type\\n datasets = []\\n\\n for i in range(noe):\\n\\n # Load only images of the environment which includes images of the stated novel item.\\n if item_to_include is not None and novelty == 'novel_item':\\n dataset_env_i = PolycraftDatasetWithSpecificItem(\\n nov_type=novelty, noi=total_noi_i, env_idx=i, p_size=n_p, scale_factor=scale_level,\\n item_name=item_to_include)\\n datasets.append(dataset_env_i)\\n # We only process the one environment with the item (maybe change this\\n # if we have more than one environement per novel_item!?)\\n break\\n\\n # No specific item given which should be included.\\n else:\\n dataset_env_i = PolycraftDatasetNoSpecificItem(\\n nov_type=novelty, noi=total_noi_i, env_idx=i, p_size=n_p, scale_factor=scale_level)\\n datasets.append(dataset_env_i)\\n\\n final_dataset = ConcatDataset(datasets)\\n\\n total_noi = len(final_dataset) # Total number of processed images from all datasets\\n\\n if(total_noi < 7):\\n print('Number of samples too small for splitting dataset in training-/valid-/test set.')\\n\\n train_noi = int(0.7 * total_noi) # Number of images used for training (70 %)\\n valid_noi = int(0.15 * total_noi) # Number of images used for validation (15 %)\\n test_noi = total_noi - train_noi - valid_noi # Number of images used for testing (15 %)\\n train_dataset, valid_dataset, test_dataset = torch.utils.data.random_split(\\n final_dataset, [train_noi, valid_noi, test_noi])\\n\\n train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True)\\n valid_loader = DataLoader(valid_dataset, batch_size=1, shuffle=True)\\n test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True)\\n\\n return train_loader, valid_loader, test_loader\",\n \"def instantiate(self):\\n return _libsbml.Submodel_instantiate(self)\",\n \"def _create_examples(self, lines: List[str], mode: Split):\\n test_mode = mode == Split.test\\n q1_index = 1 if test_mode else 3\\n q2_index = 2 if test_mode else 4\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (mode.value, line[0])\\n try:\\n text_a = line[q1_index]\\n text_b = line[q2_index]\\n label = None if test_mode else line[5]\\n except IndexError:\\n continue\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def splits(cls, exts, fields, path='./data/lang8', root='./data',\\n train='train', validation='val', test='test', **kwargs):\\n return super(USE, cls).splits(\\n path, root, train, validation, test, exts=exts, fields=fields, **kwargs)\",\n \"def _build_experiment_chiapet_embedded_list():\\n antibody_embeds = DependencyEmbedder.embed_defaults_for_type(\\n base_path='antibody',\\n t='antibody')\\n return (\\n Experiment.embedded_list + antibody_embeds\\n )\",\n \"def sample_from_subpop(instance, params, subpop):\\n y = subpop\\n x = np.random.choice([-1,+1], size=params['d'])\\n x[instance['indices'][subpop]] = instance['values'][subpop]\\n return x, y, subpop\",\n \"def get_specs(subj_name='mmddyyn_wmLoadMem02'):\\n \\n dictDlg = gui.DlgFromDict({'Participant number': '07dd19n_eyeSustAttnWM03', #subject name: month, day, year, number, and project name\\n 'Environment':['booth','eeg','Dirk VU','imac','edslab'], #which environment (aka monitor name in Tools > Monitor Center)\\n 'Restarting experiment?':False, #whether restarting an experiment that was aborted in the middle\\n 'Debug':False, #whether instructions are in english\\n 'Eye tracker':True,\\n 'Picture game':True,\\n 'Block game': True},\\n title='Welcome to the experiment', #title for GUI\\n fixed=[' '],\\n order=['Participant number','Environment','Restarting experiment?','Debug','Eye tracker']) #choose order of elements\\n if dictDlg.OK == True:\\n gui_specs = {}\\n gui_specs['subj_name']=str(dictDlg.data[0])\\n gui_specs['env'] = dictDlg.data[1]\\n gui_specs['restarting'] = dictDlg.data[2]\\n gui_specs['expt_date'] = datetime.now().strftime(\\\"%m/%d/%Y %H:%M\\\")\\n gui_specs['debug'] = dictDlg.data[3]\\n gui_specs['eyetrack'] = dictDlg.data[4]\\n gui_specs['seed'] = int(time.time())\\n gui_specs['sustattn'] = dictDlg.data[5]\\n gui_specs['changedetect'] = dictDlg.data[6]\\n else:\\n core.quit()\\n \\n #check the specs\\n assert isinstance(gui_specs['subj_name'],basestring), \\\"subj_name is not an string: %r\\\" % specs['subj_name']\\n assert isinstance(gui_specs['env'],basestring), \\\"env is not a string: %r\\\" % specs['env']\\n assert isinstance(gui_specs['expt_date'],basestring), \\\"expt_date is not a string: %r\\\" % specs['expt_date']\\n assert isinstance(gui_specs['seed'],int), \\\"seed is not a int: %r\\\" % specs['seed']\\n\\n #which environment is being used to run the experiment\\n if gui_specs['env']=='imac':\\n gui_specs['project_dir']='/Users/megan/Documents/projects/eyeSustAttnWM03/'\\n elif gui_specs['env']=='booth':\\n gui_specs['project_dir']='C:/Users/AwhVogelLab/Desktop/Megan/eyeSustAttnWM03/'\\n elif gui_specs['env']=='edslab':\\n gui_specs['project_dir']='/Users/edslab/Documents/projects/eyeSustAttnWM03/'\\n elif gui_specs['env']=='Dirk VU':\\n gui_specs['project_dir']='C:/Users/Dirk VU/Documents/Github/eyeSustAttnWM03/'\\n elif gui_specs['env']=='eeg':\\n gui_specs['project_dir']='C:/Users/awhvogellab/Desktop/Megan/eyeSustAttnWM03/' #FIX THIS LATER\\n else:\\n pass\\n #print 'ERROR: unknown environment selected in the GUI'\\n \\n #which directory to use to save the data\\n gui_specs['save_dir'] = gui_specs['project_dir'] + 'subjects/' + gui_specs['subj_name'] + '/data/beh/'\\n \\n #if the directory where data will be saved does not exist yet\\n if not os.path.isdir(gui_specs['save_dir']):\\n #print \\\"saving files to: \\\", gui_specs['save_dir']\\n os.makedirs(gui_specs['save_dir']) #this command can make multiple subfolders\\n \\n return gui_specs\",\n \"def splits(cls, search_query = 'all', max_results = 300, start = 0, reduced_words=1000, savepath='.data', split_ratio=0.7, stratified=False, strata_field='abstract',\\n random_state=None, **kwargs):\\n\\n # initialize text field\\n text_field = torchtext.data.Field(tokenize=get_tokenizer(\\\"spacy\\\"), init_token='<sos>', eos_token='<eos>', lower=True)\\n fields = [('abstract', text_field), ('paper', text_field)]\\n examples = []\\n\\n # Create new dataset by downloading from arxiv or open dataset from folder\\n if not os.path.exists(savepath):\\n os.mkdir(savepath)\\n # create directories for saving the data set\\n if not os.path.exists(os.path.join(savepath, 'temp')):\\n os.mkdir(os.path.join(savepath, 'temp'))\\n if not os.path.exists(os.path.join(savepath, 'abstracts')):\\n os.mkdir(os.path.join(savepath, 'abstracts'))\\n if not os.path.exists(os.path.join(savepath, 'paper')):\\n os.mkdir(os.path.join(savepath, 'paper'))\\n data = cls.download(search_query=search_query, max_results=max_results)\\n abstracts, papers = cls.extract_paper_and_abstract(data, savepath=savepath)\\n\\n # generate all examples\\n for i, (abstract, paper) in enumerate(zip(abstracts, papers)):\\n paper_tokenized = []\\n abstract_tokenized = []\\n # rdeduce the number of words with the textrank approach\\n textranked_paper = summarizer.summarize(paper, words=reduced_words)\\n # add start and end token\\n paper_tokenized += [u'<sos>'] + text_field.preprocess(textranked_paper) + [u'<eos>']\\n abstract_tokenized += [u'<sos>'] + text_field.preprocess(abstract) + [u'<eos>']\\n # initialize examples\\n examples.append(torchtext.data.Example.fromlist([abstract_tokenized, paper_tokenized], fields))\\n\\n # save data samples in txt files\\n with open(os.path.join(savepath,'abstracts','abstract_' + str(i) + '.txt'), 'w+', encoding='utf-8') as abstr:\\n csvwriter = csv.writer(abstr, delimiter=' ')\\n csvwriter.writerow(abstract_tokenized)\\n with open(os.path.join(savepath,'paper','paper_' + str(i) + '.txt'), 'w+', encoding='utf-8') as pap:\\n csvwriter = csv.writer(pap, delimiter=' ')\\n csvwriter.writerow(paper_tokenized)\\n\\n else:\\n # read all files in saved data path\\n paper_files = os.listdir(os.path.join(savepath,'paper'))\\n abstract_files = os.listdir(os.path.join(savepath,'abstracts'))\\n data = [[paper, abstract] for paper, abstract in zip(paper_files, abstract_files)]\\n papers_tokenized = []\\n abstracts_tokenized = []\\n # read paper and abstracts from files\\n for paper, abstract in data:\\n with open(os.path.join(savepath, 'paper', paper), encoding='utf-8') as csvfile:\\n paper = csv.reader(csvfile, delimiter=' ')\\n for pap in paper:\\n if pap:\\n papers_tokenized.append(pap)\\n with open(os.path.join(savepath, 'abstracts', abstract), encoding='utf-8') as csvfile:\\n abstract = csv.reader(csvfile, delimiter=' ')\\n for abstr in abstract:\\n if abstr:\\n abstracts_tokenized.append(abstr)\\n \\n # generate all examples\\n for abstract_tokenized, paper_tokenized in zip(abstracts_tokenized, papers_tokenized):\\n examples.append(torchtext.data.Example.fromlist([abstract_tokenized, paper_tokenized], fields))\\n\\n # create initial dataset\\n dataset = PaperAbstractDataset(examples, fields)\\n # split dataset\\n splits = dataset.split(split_ratio=split_ratio, stratified=stratified, strata_field=strata_field,\\n random_state=random_state)\\n # initialize vocabulary\\n pre_trained_vector_type = 'glove.6B.300d'\\n for d in splits:\\n for name, field in d.fields.items():\\n field.build_vocab(splits[0], vectors=pre_trained_vector_type)\\n d.filter_examples(['abstract', 'paper'])\\n return splits\",\n \"def __split_dataset(self):\\n self.train, self.valid, _, _ = train_test_split(self.data, self.data, test_size=0.2)\\n self.valid, self.test, _, _ = train_test_split(self.valid, self.valid, test_size=0.5)\",\n \"def _create_examples(self, lines: List[str], mode: Split):\\n # id,title,content,label\\n test_mode = mode == Split.test\\n title_index = 1\\n content_index = 2\\n examples = []\\n for (i, line) in enumerate(lines):\\n if i == 0:\\n continue\\n guid = \\\"%s-%s\\\" % (mode.value, line[0])\\n try:\\n text_a = line[title_index]\\n text_b = line[content_index]\\n if test_mode:\\n label = None\\n else:\\n label = line[3]\\n except IndexError:\\n continue\\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\\n return examples\",\n \"def split():\\n flag = 0\\n for chromosome in region:\\n for inf in region[chromosome]:\\n if flag == 0:\\n if chromosome not in test_set:\\n test_set[chromosome] = [inf]\\n else:\\n test_set[chromosome].append(inf)\\n else:\\n if chromosome not in train_set:\\n train_set[chromosome] = [inf]\\n else:\\n train_set[chromosome].append(inf)\\n\\n flag += 1\\n flag %= 10\",\n \"def test_similar_variants_for_varinat_analysis(self):\\n self.testcases[0].job_type = 'some_type1'\\n self.testcases[0].project_name = 'project1'\\n self.testcases[0].crash_state = 'abcde'\\n self.testcases[0].one_time_crasher_flag = False\\n self.testcases[0].crash_type = 'crash_type1'\\n self.testcases[0].security_flag = True\\n self.testcases[1].job_type = 'some_type2'\\n self.testcases[1].project_name = 'project1'\\n self.testcases[1].crash_state = 'vwxyz'\\n self.testcases[1].crash_type = 'crash_type2'\\n self.testcases[1].one_time_crasher_flag = False\\n self.testcases[1].security_flag = True\\n\\n self.testcases.append(test_utils.create_generic_testcase())\\n self.testcases[2].project_name = 'project1'\\n self.testcases[2].crash_type = 'a3'\\n\\n self.testcases.append(test_utils.create_generic_testcase())\\n self.testcases[3].project_name = 'project1'\\n self.testcases[3].crash_type = 'b4'\\n\\n self.testcases.append(test_utils.create_generic_testcase())\\n self.testcases[4].project_name = 'project1'\\n self.testcases[4].crash_type = 'c5'\\n\\n self.testcases.append(test_utils.create_generic_testcase())\\n self.testcases[5].project_name = 'project1'\\n self.testcases[5].crash_type = 'd6'\\n\\n for t in self.testcases:\\n t.put()\\n\\n # testcase2's varinat will be evaluated against testcase1\\n self.testcase_variants[0].job_type = 'fake_engine_asan_project1'\\n self.testcase_variants[0].testcase_id = self.testcases[0].key.id()\\n self.testcase_variants[0].security_flag = True\\n self.testcase_variants[1].job_type = 'some_type1'\\n self.testcase_variants[1].crash_state = 'abcde'\\n self.testcase_variants[1].crash_type = 'crash_type1'\\n self.testcase_variants[1].testcase_id = self.testcases[1].key.id()\\n self.testcase_variants[1].security_flag = True\\n self.testcase_variants.append(test_utils.create_generic_testcase_variant())\\n self.testcase_variants.append(test_utils.create_generic_testcase_variant())\\n self.testcase_variants.append(test_utils.create_generic_testcase_variant())\\n self.testcase_variants.append(test_utils.create_generic_testcase_variant())\\n\\n for v in self.testcase_variants:\\n v.put()\\n\\n grouper.group_testcases()\\n\\n for index, t in enumerate(self.testcases):\\n self.testcases[index] = data_handler.get_testcase_by_id(t.key.id())\\n\\n # Check testcases 0 and 1 are grouped together and 0 is the leader.\\n self.assertNotEqual(self.testcases[0].group_id, 0)\\n self.assertNotEqual(self.testcases[1].group_id, 0)\\n self.assertEqual(self.testcases[0].group_id, self.testcases[1].group_id)\\n self.assertTrue(self.testcases[0].is_leader)\\n self.assertFalse(self.testcases[1].is_leader)\\n\\n # Check none other testcases are grouped together.\\n for i in range(2, 6):\\n self.assertEqual(self.testcases[i].group_id, 0)\\n self.assertTrue(self.testcases[i].is_leader)\",\n \"def split_dataset(self, split):\\n trunk_pos_size = math.ceil((1 - split) * len(self.Pos))\\n trunk_neg_size = math.ceil((1 - split) * len(self.Neg))\\n trunk_num = int(1 / (1 - split))\\n pos_temp = list()\\n neg_temp = list()\\n for index in range(trunk_num):\\n pos_temp.append(self.Pos[index * trunk_pos_size:(index + 1) *\\n trunk_pos_size])\\n neg_temp.append(self.Neg[index * trunk_neg_size:(index + 1) *\\n trunk_neg_size])\\n self.test = pos_temp.pop(2) + neg_temp.pop(2)\\n # self.train = [i for item in pos_temp + neg_temp for i in item]\\n self.train = []\\n for item in pos_temp + neg_temp:\\n for i in item:\\n self.train.append(i)\\n\\n random.shuffle(self.train)\\n random.shuffle(self.test)\",\n \"def split_simplified_json_acceptor_dataset(dataset: SimpleJsonAcceptorDataset, split_list):\\n import numpy as np\\n # create a list of lengths [0.1, 0.4, 0.5] -> [100, 500, 1000(=len_data)]\\n split_list = np.multiply(np.cumsum(split_list), len(dataset)).astype(\\\"int\\\").tolist()\\n # list of shuffled indices to sample randomly\\n shuffled_idx = list(range(len(dataset)))\\n shuffle(shuffled_idx)\\n # split the data itself\\n new_data = [[] for _ in range(len(split_list))]\\n for sub_data_idx, (start, end) in enumerate(zip([0] + split_list[:-1], split_list)):\\n for i in range(start, end):\\n new_data[sub_data_idx].append(dataset.__getitem__(shuffled_idx[i]))\\n # create sub sets\\n sub_datasets = []\\n for i in range(len(new_data)):\\n ready_dict = {\\n \\\"_idx_to_chr\\\": dataset._idx_to_chr,\\n \\\"_chr_embed\\\": dataset._chr_embed,\\n \\\"data\\\": new_data[i]\\n }\\n sub_datasets.append(SimpleJsonAcceptorDataset(dataset._size, ready=ready_dict))\\n return sub_datasets\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.573789","0.57144195","0.56194884","0.5434938","0.5363377","0.53393525","0.529092","0.5277947","0.5253223","0.5229658","0.5225851","0.5225829","0.5144398","0.51441","0.5116659","0.5102679","0.5095015","0.5081049","0.5081003","0.50729406","0.5070303","0.5065203","0.5049927","0.5024096","0.50216424","0.5003964","0.5003254","0.49998808","0.49918142","0.49752128","0.49700022","0.4964888","0.49638173","0.49627593","0.49619055","0.4946955","0.4930065","0.4928167","0.49185267","0.4916097","0.48950386","0.48882186","0.48778272","0.4868582","0.48605174","0.48534107","0.4844095","0.48354325","0.48306745","0.4823075","0.48106563","0.4806949","0.48067826","0.4805074","0.4802998","0.4793792","0.47885093","0.4787499","0.4780668","0.47770116","0.47699085","0.4769795","0.4767205","0.47535613","0.4745493","0.4741595","0.47412753","0.47347718","0.4729521","0.47277564","0.47275704","0.47216836","0.47196916","0.47171268","0.4715307","0.47133154","0.47129568","0.47087923","0.4708468","0.46970624","0.46909878","0.4687093","0.46862572","0.46813545","0.46716815","0.46705794","0.4669292","0.46660492","0.46635523","0.46608192","0.46593362","0.46579936","0.46557492","0.46523604","0.46456894","0.46429417","0.46422085","0.4641384","0.46409842","0.4639165"],"string":"[\n \"0.573789\",\n \"0.57144195\",\n \"0.56194884\",\n \"0.5434938\",\n \"0.5363377\",\n \"0.53393525\",\n \"0.529092\",\n \"0.5277947\",\n \"0.5253223\",\n \"0.5229658\",\n \"0.5225851\",\n \"0.5225829\",\n \"0.5144398\",\n \"0.51441\",\n \"0.5116659\",\n \"0.5102679\",\n \"0.5095015\",\n \"0.5081049\",\n \"0.5081003\",\n \"0.50729406\",\n \"0.5070303\",\n \"0.5065203\",\n \"0.5049927\",\n \"0.5024096\",\n \"0.50216424\",\n \"0.5003964\",\n \"0.5003254\",\n \"0.49998808\",\n \"0.49918142\",\n \"0.49752128\",\n \"0.49700022\",\n \"0.4964888\",\n \"0.49638173\",\n \"0.49627593\",\n \"0.49619055\",\n \"0.4946955\",\n \"0.4930065\",\n \"0.4928167\",\n \"0.49185267\",\n \"0.4916097\",\n \"0.48950386\",\n \"0.48882186\",\n \"0.48778272\",\n \"0.4868582\",\n \"0.48605174\",\n \"0.48534107\",\n \"0.4844095\",\n \"0.48354325\",\n \"0.48306745\",\n \"0.4823075\",\n \"0.48106563\",\n \"0.4806949\",\n \"0.48067826\",\n \"0.4805074\",\n \"0.4802998\",\n \"0.4793792\",\n \"0.47885093\",\n \"0.4787499\",\n \"0.4780668\",\n \"0.47770116\",\n \"0.47699085\",\n \"0.4769795\",\n \"0.4767205\",\n \"0.47535613\",\n \"0.4745493\",\n \"0.4741595\",\n \"0.47412753\",\n \"0.47347718\",\n \"0.4729521\",\n \"0.47277564\",\n \"0.47275704\",\n \"0.47216836\",\n \"0.47196916\",\n \"0.47171268\",\n \"0.4715307\",\n \"0.47133154\",\n \"0.47129568\",\n \"0.47087923\",\n \"0.4708468\",\n \"0.46970624\",\n \"0.46909878\",\n \"0.4687093\",\n \"0.46862572\",\n \"0.46813545\",\n \"0.46716815\",\n \"0.46705794\",\n \"0.4669292\",\n \"0.46660492\",\n \"0.46635523\",\n \"0.46608192\",\n \"0.46593362\",\n \"0.46579936\",\n \"0.46557492\",\n \"0.46523604\",\n \"0.46456894\",\n \"0.46429417\",\n \"0.46422085\",\n \"0.4641384\",\n \"0.46409842\",\n \"0.4639165\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7028728"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":12883,"cells":{"query":{"kind":"string","value":"For the time being this is TGF/baseline and control/baseline The choice of 0 or 96 will make a difference"},"document":{"kind":"string","value":"def calculate_ddct(self, baseline_time=0):\n\n if baseline_time == 0:\n baseline = self.baseline_data['dct'][0]\n\n elif baseline_time == 96:\n baseline = self.baseline_data['dct'][96]\n\n elif baseline_time == 'average':\n baseline = (self.baseline_data['dct'][0] + self.baseline_data['dct'][96]) / 2\n\n control =self.treatment_data.query('treatment == \"Control\"')['dct']\n tgf = self.treatment_data.query('treatment == \"TGFb\"')['dct']\n control.index = control.index.droplevel(1)\n tgf.index = tgf.index.droplevel(1)\n baseline.index = baseline.index.droplevel(1)\n\n time = control.columns\n\n tgf = pandas.concat([tgf[i]/baseline for i in tgf.columns], axis=1)\n control = pandas.concat([control[i]/baseline for i in control.columns], axis=1)\n\n control.columns = time\n tgf.columns = time\n\n control = pandas.DataFrame(control.stack())\n tgf = pandas.DataFrame(tgf.stack())\n control['treatment'] = 'Control'\n tgf['treatment'] = 'TGFb'\n df = pandas.concat([control, tgf]).reset_index()\n df.rename(columns={0: 'ddct'})\n return df"},"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 _getBaselineThresh(self):\n print('Calculating 10% baseline')\n self.baseline = obrienBaseline.obrienBaseline(\n self.d['dos1rate'], timeWidth=5.0, \n cadence=0.1)\n self.peak_std = ( (self.d['dos1rate'][self.peakInd]/10 - \n self.baseline[self.peakInd]/10)/ \n np.sqrt(self.d['dos1rate'][self.peakInd]/10))\n return","def baseline_TVOC(self) -> int:\n return self.get_iaq_baseline()[1]","def evaluate_baseline(test_data):\n\n # create mapping xor diff -> biterrors \n error_values = np.array([bin(x).count('1') for x in range(CONST_POINTS)]) \n\n x_raw, x = test_data\n means = Data_generator().constellations[MODULATION][1]\n x_recon = np.argmin(np.abs(x[:, None] - means[None, :]), axis=1)\n\n diff = x_recon^x_raw # bitwise comparison\n bit_errors = np.sum(error_values[diff])\n ber = bit_errors/(NUM_SAMPLES*BITS_PER_SYMBOL)\n return ber","def gtf(self):\n\t #if tank is empty, conductance is 0\n\t if self.tx <= 0:\n\t return 0.\n\t\t#returns 0.5, as a function of TAI\n\t else:\n\t return 0.5","def baseline_score(self,t0,t1):\n return len(set(t0) & set(t1))/len(set(t0).union(set(t1)))","def baseline(self):\n return self.data[self.data['treatment'] == 'Baseline']","def set_iaq_baseline( # pylint: disable=invalid-name\n self, eCO2: int, TVOC: int\n ) -> None:\n if eCO2 == 0 and TVOC == 0:\n raise RuntimeError(\"Invalid baseline\")\n buffer = []\n for value in [TVOC, eCO2]:\n arr = [value >> 8, value & 0xFF]\n arr.append(self._generate_crc(arr))\n buffer += arr\n self._run_profile((\"iaq_set_baseline\", [0x20, 0x1E] + buffer, 0, 0.01))","def baseline(ant_ID1, ant_ID2):\n return ant_pos[ant_ID2] - ant_pos[ant_ID1]","def find_gains_for_baseline(self, t, bl):\n\n ant1, ant2 = baselines_2_ants([bl])\n\n # Find indx of gains entries containing ``t`` with ant1 & ant2\n indx1 = np.where((t <= self._data['stop']) & (t >= self._data['start'])\n & (self._data['antenna'] == ant1))[0]\n indx2 = np.where((t <= self._data['stop']) & (t >= self._data['start'])\n & (self._data['antenna'] == ant2))[0]\n\n # Now each gains# has shape (#if, #pol)\n gains1 = np.squeeze(self._data[indx1]['gains'])\n gains2 = np.squeeze(self._data[indx2]['gains'])\n\n # ``gains12`` has shape (#stokes, #nif)\n gains12 = np.asarray([gains1[:, 0] * np.conjugate(gains2[:, 0]),\n gains1[:, 1] * np.conjugate(gains2[:, 1]),\n gains1[:, 0] * np.conjugate(gains2[:, 1]),\n gains1[:, 1] * np.conjugate(gains2[:, 0])])\n\n return gains12","def test_calculate_tutor_baseline(self):\n tmax = 40.0\n dt = 1.0\n ini_rate = 80.0\n baseline_n = 5\n\n rate1 = ini_rate + 20.0\n rate2 = ini_rate - 10.0\n\n nruns = 10\n nsteps = int_r(tmax/dt)\n\n tutor = SimpleNeurons(2, out_fct=lambda i:\n [rate1, rate2] if i < nsteps/2 else [rate2, rate1])\n reward = MockReward(lambda _: 0.0)\n tutor_rule = ReinforcementTutorRule(tutor, reward, tau=0,\n constrain_rates=False, ini_rate=ini_rate, learning_rate=0.1,\n use_tutor_baseline=True, baseline_n=baseline_n)\n\n factor = 1 - 1.0/baseline_n\n\n for i in xrange(nruns):\n tutor_rule.reset_rates()\n\n sim = simulation.Simulation(tutor, reward, tutor_rule, dt=dt)\n sim.run(tmax)\n\n crt_baseline = tutor_rule.baseline\n\n self.assertEqual(np.ndim(crt_baseline), 2)\n self.assertEqual(np.shape(crt_baseline)[0], nsteps)\n self.assertEqual(np.shape(crt_baseline)[1], 2)\n\n expected1 = rate1 + (ini_rate - rate1)*factor**(i+1)\n expected2 = rate2 + (ini_rate - rate2)*factor**(i+1)\n\n self.assertLess(np.max(np.abs(crt_baseline[:nsteps/2, 0] - expected1)),\n 1e-6)\n self.assertLess(np.max(np.abs(crt_baseline[nsteps/2:, 0] - expected2)),\n 1e-6)\n\n self.assertLess(np.max(np.abs(crt_baseline[:nsteps/2, 1] - expected2)),\n 1e-6)\n self.assertLess(np.max(np.abs(crt_baseline[nsteps/2:, 1] - expected1)),\n 1e-6)","def test_no_backg_subt():\n \n test_object = fa.read_in_envision(data_csv=HsHis6_PEX5C_vs_HsPEX5C, platemap_csv=Hs_His6_PEX5C_vs_HsPEX5C_platemap, data_type='plate', size=384)\n test_object.calculate_r_i(correct=True, plot_i=False, thr=80)","def rec_default(self):\n self.phase_triggers.setText('(0,1,320)')\n self.phase_min.setText('-1.57')\n self.phase_max.setText('1.57')","def SuperTrend(df, period, multiplier, ohlc=['open', 'high', 'low', 'close']):\n\n ATR(df, period, ohlc=ohlc) \n atr = 'ATR_' + str(period) \n st = 'ST_' + str(period) + '_' + str(multiplier) \n stx = 'STX_' + str(period) + '_' + str(multiplier) \n \"\"\" \n SuperTrend Algorithm : \n BASIC UPPERBAND = (HIGH + LOW) / 2 + Multiplier * ATR \n BASIC LOWERBAND = (HIGH + LOW) / 2 - Multiplier * ATR \n FINAL UPPERBAND = IF( (Current BASICUPPERBAND < Previous FINAL UPPERBAND) or (Previous Close > Previous FINAL UPPERBAND)) \n THEN (Current BASIC UPPERBAND) ELSE Previous FINALUPPERBAND) \n FINAL LOWERBAND = IF( (Current BASIC LOWERBAND > Previous FINAL LOWERBAND) or (Previous Close < Previous FINAL LOWERBAND)) \n THEN (Current BASIC LOWERBAND) ELSE Previous FINAL LOWERBAND) \n SUPERTREND = IF((Previous SUPERTREND = Previous FINAL UPPERBAND) and (Current Close <= Current FINAL UPPERBAND)) THEN \n Current FINAL UPPERBAND \n ELSE \n IF((Previous SUPERTREND = Previous FINAL UPPERBAND) and (Current Close > Current FINAL UPPERBAND)) THEN \n Current FINAL LOWERBAND \n ELSE \n IF((Previous SUPERTREND = Previous FINAL LOWERBAND) and (Current Close >= Current FINAL LOWERBAND)) THEN \n Current FINAL LOWERBAND \n ELSE \n IF((Previous SUPERTREND = Previous FINAL LOWERBAND) and (Current Close < Current FINAL LOWERBAND)) THEN \n Current FINAL UPPERBAND \n \"\"\" \n # Compute basic upper and lower bands \n df['basic_ub'] = (df[ohlc[1]] + df[ohlc[2]]) / 2 + multiplier * df[atr] \n df['basic_lb'] = (df[ohlc[1]] + df[ohlc[2]]) / 2 - multiplier * df[atr]\n\n # Compute final upper and lower bands \n df['final_ub'] = 0.00 \n df['final_lb'] = 0.00 \n for i in range(period, len(df)): \n df['final_ub'].iat[i] = df['basic_ub'].iat[i] if df['basic_ub'].iat[i] < df['final_ub'].iat[i - 1] or df['Close'].iat[i - 1] > df['final_ub'].iat[i - 1] else df['final_ub'].iat[i - 1] \n df['final_lb'].iat[i] = df['basic_lb'].iat[i] if df['basic_lb'].iat[i] > df['final_lb'].iat[i - 1] or df['Close'].iat[i - 1] < df['final_lb'].iat[i - 1] else df['final_lb'].iat[i - 1] \n # Set the Supertrend value \n df[st] = 0.00 \n for i in range(period, len(df)): \n df[st].iat[i] = df['final_ub'].iat[i] if df[st].iat[i - 1] == df['final_ub'].iat[i - 1] and df['Close'].iat[i] <= df['final_ub'].iat[i] else 0\n df['final_lb'].iat[i] if df[st].iat[i - 1] == df['final_ub'].iat[i - 1] and df['Close'].iat[i] > df['final_ub'].iat[i] else 0\n df['final_lb'].iat[i] if df[st].iat[i - 1] == df['final_lb'].iat[i - 1] and df['Close'].iat[i] >= df['final_lb'].iat[i] else 0\n df['final_ub'].iat[i] if df[st].iat[i - 1] == df['final_lb'].iat[i - 1] and df['Close'].iat[i] < df['final_lb'].iat[i] else 0.00 \n # Mark the trend direction up/down \n df[stx] = np.where((df[st] > 0.00), np.where((df[ohlc[3]] < df[st]), 'down', 'up'), np.NaN)\n\n # Remove basic and final bands from the columns \n df.drop(['basic_ub', 'basic_lb', 'final_ub', 'final_lb'], inplace=True, axis=1) \n df.fillna(0, inplace=True)\n\n return df","def baseline(data):\n weights = weighting(data)\n return np.inner(weights,data['clicks'])/weights.sum()","def PG_baseline(self, p, w, tau):\n tau = np.array(tau)\n T = len(tau)\n A = tau[:, 1]\n R = tau[:, 2]\n\n prob = p\n base = w\n estG = self.estG(R, self.gamma, T)\n\n delta = estG - self.value(base)\n\n for t in range(T):\n base += self.alphabase * delta[t] * self.dval(base)\n prob += self.alpha * self.gamma**t * delta[t] * self.gradient(prob, A[t])\n\n return prob, base","def fGT(self):\n pass","def calc_pre_intertie_generation (self):\n\n self.pre_intertie_generation = \\\n self.forecast.get_generation(self.start_year,self.end_year)\n\n gen_eff = self.cd[\"diesel generation efficiency\"]\n self.pre_intertie_generation_fuel_used = \\\n self.pre_intertie_generation / gen_eff\n\n #~ print 'self.baseline_generatio',self.baseline_generation","def baseline(self):\n if getattr(self, \"_baseline\", None) is None:\n self._baseline = (self.container.height - 1) / 2\n return self._baseline","def test_calculate_tst_rate_coefficient(self):\n self.assertEqual(\"%0.7f\" % self.kineticsjob.reaction.calculate_tst_rate_coefficient(self.TminValue),\n str(46608.5904933))\n self.assertEqual(\"%0.5f\" % self.kineticsjob.reaction.calculate_tst_rate_coefficient(self.Tmaxvalue),\n str(498796.64535))","def test_GBL_tau_inst():\n dz = 0.05\n z = numpy.arange(0., 80. + 1.5*dz, dz)\n\n # Fully ionized H and He\n x_ionH = 1.0\n x_ionHe = 2.0\n\n cosmo = {}\n cosmo['omega_M_0'] = numpy.array([[0.3],[0.6],[1.0]])\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\n cosmo['h'] = 0.65\n cosmo['omega_b_0'] = 0.02 / cosmo['h']**2.\n cosmo['Y_He'] = 0.24\n cd.set_omega_k_0(cosmo)\n\n tau_inst = cr.optical_depth_instant(z, x_ionH=x_ionH, x_ionHe=x_ionHe, \n **cosmo)\n tau_int = cr.integrate_optical_depth(x_ionH, x_ionHe, z, **cosmo)\n\n linestyle = ['-', ':', '--']\n \n pylab.figure()\n pylab.subplot(2,1,1)\n pylab.title(\"Compare to GB&L fig. 1 (astro-ph/9812125v3.)\")\n for i in range(len(linestyle)):\n pylab.plot(z, tau_inst[i], ls=linestyle[i], color='b')\n pylab.plot(z, tau_int[i], ls=linestyle[i], color='r')\n\n pylab.xlim(0,80)\n pylab.ylim(0,1)\n pylab.xlabel(r\"$\\mathrm{z_{ion}}$\")\n pylab.ylabel(r\"$\\tau$\")\n \n pylab.subplot(2,1,2)\n for i in range(len(linestyle)):\n pylab.plot(z, \n 1.e4 * (tau_int[i] - tau_inst[i])/tau_inst[i], \n ls=linestyle[i], color='k')\n diff = (tau_int[i] - tau_inst[i]) / tau_inst[i]\n diff[numpy.isnan(diff)] = 0.0\n print(\"max fractional error in num. int. = %.3g\" % \n numpy.max(numpy.abs(diff))\n )\n ntest.assert_array_less(numpy.abs(diff), \n numpy.zeros(diff.shape) + 2.e-4)\n\n pylab.xlim(0,40)\n pylab.xlabel(r\"$\\mathrm{z_{ion}}$\")\n pylab.ylabel(r\"$\\mathrm{10^4 \\times (num.\\tau - ana.\\tau)/ana.\\tau}$\")","def test_use_tutor_baseline(self):\n tmax = 40.0\n dt = 1.0\n ini_rate = 80.0\n\n nruns = 11\n\n tutor = SimpleNeurons(2, out_fct=lambda _: [100.0, 60.0])\n reward = MockReward(lambda t: 1.0 if t < tmax/2 else -1)\n tutor_rule = ReinforcementTutorRule(tutor, reward, tau=0,\n constrain_rates=False, ini_rate=ini_rate, learning_rate=0.1)\n\n tutor_rule.use_tutor_baseline = True\n tutor_rule.baseline_n = 5\n\n for i in xrange(nruns):\n # we first set the baselines for the two neurons to some values different\n # from tutor_rule's ini_rate, and then in the last round, we test how the\n # rates change\n if i == nruns-1:\n tutor.out_fct = lambda _: [80.0, 80.0]\n\n tutor_rule.reset_rates()\n\n sim = simulation.Simulation(tutor, reward, tutor_rule, dt=dt)\n sim.run(tmax)\n\n drates = tutor_rule.rates - ini_rate\n\n # for the first neuron, for t < tmax/2, the current firing rate is below the\n # baseline and the reward is positive, so the rates should *decrease*\n # for t >= tmax/2, the rates should *increase*\n # the opposite should happen for the second neuron\n mask = (np.arange(0, tmax, dt) < tmax/2)\n\n self.assertGreater(np.min(drates[mask, 1]), 0)\n self.assertLess(np.max(drates[mask, 0]), 0)\n\n self.assertGreater(np.min(drates[~mask, 0]), 0)\n self.assertLess(np.max(drates[~mask, 1]), 0)","def test_coded_freq(self):\n self.assertAlmostEqual(self.g.coded_freq(), 10 / 18)","def acc_b_tr(self):\r\n return self._acc_b_tr","def test_xx1_thr(self):\n u_spec = leabra.UnitSpec()\n u_spec.act_thr = 0.25\n u = leabra.Unit(spec=u_spec)\n self.assertEqual(u_spec.xx1(-0.1), 0.0)\n self.assertTrue(0.0 < u_spec.xx1(0.1))\n self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)\n self.assertTrue(0.1 < u_spec.noisy_xx1(0.1))","def baseline_correction(df, pup_col, time_col, baseline_range, method='subtractive'):\r\n \r\n if method not in ['subtractive','divisive']:\r\n raise Exception(\"Invalid baseline correction method. Please use 'subtractive' or 'divisive'.\")\r\n \r\n bl_mean = df.loc[(df[time_col] >= baseline_range[0]) & (df[time_col] < baseline_range[1])][pup_col].median()\r\n \r\n if method == 'subtractive':\r\n df[pup_col+'_bsl'] = df[pup_col] - bl_mean\r\n \r\n elif method == 'divisive':\r\n df[pup_col+'_bsl'] = df[pup_col]/bl_mean\r\n \r\n return df","def validation_tpr_at_98tpr(self):\r\n\r\n return self.validation_tpr_at_confidence(self.confidence_at_tpr(0.98))","def evalBaseline(self, df = None):\n \n if (df is None):\n self.r_b = self.df.merge(self.df_user[[\"user ind\", \"b_u\"]], on = \"user ind\")\n self.r_b = self.r_b.merge(self.df_item[[\"item ind\", \"b_i\"]], on = \"item ind\")\n self.r_b[\"baseline\"] = self.r_mean + self.r_b[\"b_u\"] + self.r_b[\"b_i\"]\n \n \n return self.r_b[[\"user id\", \"item id\", \"baseline\"]]\n \n else:\n df = df.merge(self.df_user, on = \"user id\").merge(self.df_item, on = \"item id\")\n df[\"baseline\"] = self.r_mean + df[\"b_u\"] + df[\"b_i\"]\n \n # clip the score to the interval [1, 5]\n df[\"baseline\"] = np.minimum(np.maximum(df[\"baseline\"], 1), 5)\n \n return df[[\"user id\", \"item id\", \"baseline\"]]","def work(char, base, scale_stat, factor):\n added = int(math.floor(char.__dict__[scale_stat] / factor))\n earned = base + added\n return [(\"gold\", earned)]","def baseline_eCO2(self) -> int:\n return self.get_iaq_baseline()[0]","def baselineFrames(self):\n frames=[]\n for tag,T1,T2 in [x for x in self.tags if x[0]=='baseline']:\n for i,timePoint in enumerate(self.conf['times']):\n if timePoint>=T1*60 and timePoint<=T2*60:\n frames.append(i)\n return frames\n else:\n return [0]","def gtVcf(ref, alt, gt):\n\tif gt == ref: return \"0\"\n\tif gt == alt: return \"1\"\n\treturn \".\"","def _get_tr(cls, data):\n\t\tprev_close = data['close_-1_s']\n\t\thigh = data['high']\n\t\tlow = data['low']\n\t\tc1 = high - low\n\t\tc2 = np.abs(high - prev_close)\n\t\tc3 = np.abs(low - prev_close)\n\t\tdata['tr'] = np.max((c1, c2, c3), axis=0)","def test_gtf(self):\n #TODO write bed tests","def baseline(*args):\n XTrain, XTest, yTrain, yTest = args\n clf = DecisionTreeClassifier(random_state=42)\n clf.fit(XTrain, yTrain)\n return clf.score(XTest, yTest), clf.feature_importances_","def getETA():","def getETA():","def get_gains(self):\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x8000+i,0)/100 for i in range(4)])","def __init__(self):\n super().__init__()\n self.TERRAIN_VARIANCE = 0.0","def _baseline_value(self):\n t = self['primary']\n return np.median(t.data[:int(10e-3/t.dt)])","def okapiTF(self, tf, dlen, avgdlen):\n return tf / (tf + 0.5 + 1.5 * (dlen/avgdlen))","def T1_contrast():\n t = np.linspace(0, 10000, 10000)\n s1 = MZ(t, 200, 900)\n s2 = MZ(t, 200, 1200)\n r = np.argmax(s1 - s2)\n print(f\"{r:.2f}\")\n plt.plot(t, s1, label=\"White matter\")\n plt.plot(t, s2, label=\"Grey matter\")\n plt.legend()\n plt.show()","def coverage(self):\r\n return 0, 1","def claim_document_baseline():\n param_range = namedtuple('param_range','start, end')\n alpha_settings = param_range(0,1)#,param_range(10,11)\n beta_settings = param_range(0,1)#,param_range(9,10)] #as it finished at beta=0.9\n lambda_settings = param_range(0,11)\n \n claim_document_baseline_LOO(alpha_settings,beta_settings,lambda_settings)","def tGain(self, dt, r):\n\t return 1./(10.**6)*r#*precip.r","def front_column_model_p_gain():","def test_error_at_98tpr(self):\r\n\r\n return self.test_error_at_confidence(self.confidence_at_tpr(0.98))","def get_iaq_baseline(self) -> List[int]:\n # name, command, signals, delay\n return self._run_profile((\"iaq_get_baseline\", [0x20, 0x15], 2, 0.01))","def testbaselinelc(self):\n a_in = os.path.join(self.datadir,\n 'monol_testA_E3-50_lc' + HEN_FILE_EXTENSION)\n out = os.path.join(self.datadir, 'monol_test_baselc')\n command = '{0} -o {1} -p 0.001 --lam 1e5'.format(a_in, out)\n\n hen.lcurve.baseline_main(command.split())\n out_lc = hen.io.load_lcurve(out + '_0' + HEN_FILE_EXTENSION)\n assert hasattr(out_lc, 'base')\n gti_to_test = hen.io.load_events(self.first_event_file).gti\n assert np.allclose(gti_to_test, out_lc.gti)","def tpr_at_98tpr(self):\r\n\r\n return self.tpr_at_confidence(self.confidence_at_tpr(0.98))","def plot_tuning_curves(self, baseline_rate=10.):\n x = np.arange(0, 1 + 0.01, 0.01)\n l0 = self.data['L0']\n l1 = self.data['L1']\n y_on = np.exp(np.log(l0) + x * np.log(l1 / l0))\n y_off = np.exp(np.log(l0) + (1 - x) * np.log(l1 / l0))\n plt.plot(x, y_on, label='ON')\n plt.plot(x, y_off, label='OFF')\n plt.plot(x, baseline_rate + 0 * x, '--')\n # plt.xlabel('Stimulus intensity')\n # plt.ylabel('Firing Rate (Hz)')\n # plt.title('Firing rate as a function \\n of Stimulus Intensity')\n # plt.legend()","def all_baselines():\n for i in range(len(active_ants)):\n ID1 = active_ants[i]\n for j in range(i + 1, len(active_ants[i + 1:])):\n ID2 = active_ants[j]\n print(\"Baseline between antennae \" + str(ID1) + \\\n \" and \" + str(ID2) + \" = \" + str(ant.baseline(ID1, ID2)))","def __get_change(self, current, previous):\n current = float(current)\n previous = float(previous)\n if current == previous:\n return 0\n try:\n r = (abs(current - previous) / previous) * 100\n if r > 100:\n r = 100\n return round(r)\n except ZeroDivisionError:\n return 100","def prescaler(self) -> int:","def compare_strategies(strategy, baseline=always_roll(5)):\r\n as_first = 1 - make_average(play)(strategy, baseline)\r\n as_second = make_average(play)(baseline, strategy)\r\n return (as_first + as_second) / 2 # Average the two results\r","def baseline(spectra):\n\n return spectra - np.mean(spectra, axis=0)","def baseline_total_organic_compound(self):\n return self.indoor_air_quality_baseline[1]","def preferred_vertical_rate(self):\n pref_code = (self._block[2] >> 5) & 0x03 # Ranges 00-11 (0-3)\n supp_code = self._block[2] & 0x1F # 5 bits long\n\n if pref_code == 0x01 and supp_code & 0x01:\n pref_code = 4\n return self._ref_rates[pref_code][1]","def set_defensive_ratio(self):\n bx = self.get_standard_stats()\n team = self.get_team_stats()\n opp_team = self.get_opp_team_stats()\n if bx[\"minutes\"] > 0:\n opp_fga = opp_team[\"t2p_int\"] + opp_team[\"t3p_int\"]\n opp_fgm = opp_team[\"t2p_conv\"] + opp_team[\"t3p_conv\"]\n try:\n dor = Decimal(opp_team[\"reb_of\"] / (opp_team[\"reb_of\"] + team[\"reb_def\"]))\n except ZeroDivisionError:\n print(BCOLORS.FAIL + \"Error: División por cero\" + BCOLORS.ENDC)\n dor = 0\n except InvalidOperation:\n print(BCOLORS.FAIL + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n dor = 0\n\n try:\n dfg = Decimal(opp_fgm / opp_fga)\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n dfg = 0\n try:\n fmwt = Decimal((dfg * (1 - dor)) / (dfg * (1 - dor) + (1 - dfg) * dor))\n except:\n fmwt = 0\n stops1 = bx[\"steals\"] + bx[\"block_shots\"] * fmwt * (1 - Decimal('1.07') * dor) + bx[\"reb_def\"] * (1 - fmwt)\n\n try:\n stops2 = (Decimal((opp_fga - opp_fgm - team[\"block_shots\"]) / team[\"minutes\"]) * fmwt * (1 - Decimal('1.07') * dor) + Decimal((opp_team[\"turnovers\"] - team[\"steals\"]) / team[\"minutes\"])) * bx[\"minutes\"] + Decimal(bx[\"fouls_cm\"] / team[\"fouls_cm\"]) * Decimal('0.4') * opp_team[\"tl_int\"] * (1 - Decimal(opp_team[\"tl_conv\"] / opp_team[\"tl_int\"]))**2\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n stops2 = 0\n except InvalidOperation:\n print(BCOLORS.WARNING + \"Error: Invalid Operation\" + BCOLORS.ENDC)\n stops2 = 0\n\n stops = stops1 + stops2\n poss = self.get_team_possessions()\n if bx[\"minutes\"] > 0:\n stop_percentage = (float(stops) * float(opp_team[\"minutes\"])) / (float(poss) * float(bx[\"minutes\"]))\n else:\n stop_percentage = 0.00\n opp_points = opp_team[\"t2p_conv\"] * 2 + opp_team[\"t3p_conv\"] * 3 + opp_team[\"tl_conv\"]\n team_defensive_rating = 100 * (float(opp_points) / poss)\n try:\n d_pts_per_scposs = float(opp_points) / (float(opp_fgm) + (1 - (1 - (float(opp_team[\"tl_conv\"]) / float(opp_team[\"tl_int\"])))**2) * float(opp_team[\"tl_int\"])*0.4)\n result = Decimal(team_defensive_rating) + Decimal('0.2') * (100 * Decimal(d_pts_per_scposs) * (1 - Decimal(stop_percentage)) - Decimal(team_defensive_rating))\n except ZeroDivisionError:\n print(BCOLORS.WARNING + \"Error: División por cero\" + BCOLORS.ENDC)\n d_pts_per_scposs = 0\n result = 0.00\n\n\n\n # print(\"dor: \" + str(dor))\n # print(\"dfg: \" + str(dfg))\n # print(\"fmwt: \" + str(fmwt))\n # print(\"stops1: \" + str(stops1))\n # print(\"stops2: \" + str(stops2))\n # print(\"stops: \" + str(stops))\n # print(\"poss: \" + str(poss))\n # print(\"stop_percentage: \" + str(stop_percentage))\n # print(\"opp_points: \" + str(opp_points))\n # print(\"team_defensive_rating: \" + str(team_defensive_rating))\n # print(\"d_pts_per_scposs: \" + str(d_pts_per_scposs))\n # print(\"drtg: \" + str(result) + \"\\n\")\n else:\n result = 0.00\n self.drtg = \"%.2f\" % round(result, 2)","def baseline_co2_equivilant(self):\n return self.indoor_air_quality_baseline[0]","def get_max_gains(self):\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x800c+i,100)/100 for i in range(4)])","def learning_rate_range():\n # Lower and upper bounds\n #######\n lower_bound = 0.1 \n upper_bound = 1e-6\n #######\n return lower_bound, upper_bound","def get_rec_rate_H_caseB(T):\n Tinv = 1.0/T\n bb = 315614.0*Tinv\n cc = 115188.0*Tinv\n dd = 1.0 + np.power(cc, 0.407)\n return 2.753e-14*np.power(bb, 1.5)*np.power(dd, -2.242)","def dbgain(self, pt_1, pt_2):\n raise NotImplementedError","def tickDiff(tStart, tEnd):\n tDiff = tEnd - tStart\n if tDiff < 0:\n tDiff += (1 << 32)\n return tDiff","def _rms_sort(self):\n if self.image_status == 'match':\n return \"000000\"\n elif self.image_status == 'diff':\n if self.rms is None: # Shape mismatch\n return \"999999\"\n # RMS will be in [0, 255]\n return f\"{(self.rms + 2) * 1000:06.0f}\"\n else: # Missing baseline image\n return \"000001\"","def test_decaydata_branching_fraction(self):\n\n data = decaydata.DecayData(\"icrp107\")\n self.assertEqual(data.branching_fraction(\"K-40\", \"Ca-40\"), 0.8914)\n self.assertEqual(data.branching_fraction(\"K-40\", \"H-3\"), 0.0)","def g(self):\n return 2","def TVOC(self) -> int:\n return self.iaq_measure()[1]","def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\n total_days=df.shape[0]\n today_invt_dict=invt_dict\n invt_daily_list=[] # invt after today's transaction\n net_wealth_list=[]\n\n for i in range(total_days):\n if i==0:\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\n elif i==total_days-1: # last day\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\n invt_daily_list.append(today_invt_dict)\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\n \n PrintResult(\"Baseline Strategy\", net_wealth_list)\n plt.plot(net_wealth_list)\n plt.title(\"Baseline (1st day buy->hold->last day sell) Strategy\")\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\n plt.show()\n return","def indoor_air_quality_baseline(self):\n # name, command, signals, delay\n return self._i2c_read_words_from_cmd(command=[0x20, 0x15], reply_size=2, delay=0.01)","def baseline_deviation_2_rule(_m, y):\r\n\r\n if y == m.Y.first():\r\n return Constraint.Skip\r\n else:\r\n return m.z_b2[y] >= m.baseline[y - 1] - m.baseline[y]","def correct_baseline(trace, config=None):\n if config is None:\n config = get_config()\n\n # Integrate twice to get the displacement time series\n disp_data = get_disp(trace, method=config[\"integration\"][\"method\"])\n\n # Fit a sixth order polynomial to displacement time series, requiring\n # that the 1st and 0th order coefficients are zero\n time_values = (\n np.linspace(0, trace.stats.npts - 1, trace.stats.npts) * trace.stats.delta\n )\n poly_cofs = list(curve_fit(_poly_func, time_values, disp_data)[0])\n poly_cofs += [0, 0]\n\n # Construct a polynomial from the coefficients and compute\n # the second derivative\n polynomial = np.poly1d(poly_cofs)\n polynomial_second_derivative = np.polyder(polynomial, 2)\n\n # Subtract the second derivative of the polynomial from the\n # acceleration trace\n trace.data -= polynomial_second_derivative(time_values)\n trace.setParameter(\"baseline\", {\"polynomial_coefs\": poly_cofs})\n\n return trace","def set_dre(self):\n bx = self.get_standard_stats()\n ptos = float(bx[\"t2p_conv\"]*2 + bx[\"t3p_conv\"]*3 + bx[\"tl_conv\"])\n fga = float(bx[\"t2p_int\"] + bx[\"t3p_int\"])\n trb = float(bx[\"reb_def\"] + bx[\"reb_of\"])\n d1 = ptos + (0.2*trb) + (1.7*float(bx[\"steals\"])) + (0.535*float(bx[\"block_shots\"])) + (0.5*float(bx[\"assists\"]))\n d2 = (0.9*fga) + (0.35*float(bx[\"tl_int\"])) + (1.4*float(bx[\"turnovers\"])) + (0.136*float(bx[\"minutes\"]))\n result = \"%.2f\" % round(d1-d2, 2)\n self.dre = \"%.2f\" % round(Decimal(result)/bx[\"games\"], 2)","def tweak(rg):\n (r, g) = rg\n if r == 0 and g == 0:\n return 0, 0\n elif r == 1 and g == 1:\n return 2, 2\n elif r == 0:\n if g == 1:\n g += 1\n else:\n g -= 1\n elif g == 0:\n if r == 1:\n r += 1\n else:\n r -= 1\n else:\n r -= 1\n g -= 1\n return r, g","def proz(): \r\n print(\"processing: \",CURDATA()[0]) \r\n Check_180turn(left_boundary,right_boundary)\r\n EF() #exponential window multiplication + fourier\r\n APK0() #1. Phase correction 0th Ordnung\r\n APK1() #1. Phase correction 1st Ordnung\r\n ABS() #Baseline correction\r\n APK()\r\n ABS() #Baseline correction\r\n Check_180turn(left_boundary,right_boundary)","def brate(self):\n try:\n return self.pos / self.runtime\n except ZeroDivisionError:\n return 0","def calc_HEX_mix(Q1, Q2, t1, m1, t2, m2):\n if Q1 > 0 or Q2 > 0:\n tavg = (t1 * m1 + t2 * m2) / (m1 + m2)\n else:\n tavg = 0\n return np.float(tavg)","def supervised_baseline(self, supervised_decoder):\r\n supervised_decoder_pred, _, baseline_reward = sm.validationMetricPerformance(\r\n input_pairs=[(self.source_sentence, self.target_sentence)], encoder=self.supervised_encoder,\r\n decoder=supervised_decoder, similarity_model=self.similarity_model, fluency_model=self.fluency_model,\r\n ESIM_model=self.ESIM_model, logr_model=self.logr_model, std_scaler=self.std_scaler,\r\n similarity_dist=self.similarity_dist, fluency_dist=self.fluency_dist, ESIM_dist=self.ESIM_dist,\r\n vocab_index=vocab_index, verbose=False, metric=self.reward_function)\r\n \r\n supervised_decoder_pred = supervised_decoder_pred[0][1]\r\n \r\n return supervised_decoder_pred, np.around(baseline_reward, 3)","def get_fare(self):\r\n return super().get_fare()*self.fanciness_rating+self.flagfall","async def decide(self):\n return 0., 0., 0.","def convert_flowrate(setting):\r\n return 0.8991*setting - 62.339","def b_vs_r(r, t=.97):\n min_b = (np.log(1-t))/(np.log(1-.95**r))\n return min_b","def functionality(self):\n self._functionality = 0.12 * self.CAMC + 0.22 * self.NOP + 0.22 * self.CIS + 0.22 * self.DSC + 0.22 * self.NOH\n return round(self._functionality, 5)","def fixed_baseline(random_seeds, train_data, test_data):\n\n err = 0.\n\n for seed in random_seeds:\n np.random.seed(seed)\n\n data = prep_data(train_data, test_data)\n\n wrong = 0.\n for i in range(data['test_rows']):\n if not data['test_ys'][i] == 1.0:\n wrong += 1\n\n err += wrong / data['test_rows']\n\n return err / len(random_seeds)","def __call__(self,t=0):\n\n return (self.g(t) if (t<self.tc) else self.itpr(t))","def bad_start_rate(labelled,str):\n#\tlabelled = RawClaim.objects.exclude(correcttrim=\"\")\n\tfiltered = set([l for l in labelled if fixstring(l.sentence).startswith(str)])\n\twrong = set([l for l in filtered if l.correcttrim!=\"X\"])\n\tright = filtered - wrong\n\treturn (float(len(right))/len(filtered),wrong,right)","def reusability(self):\n self._reusability = -0.25 * self.DCC + 0.25 * self.CAMC + 0.5 * self.CIS + 0.5 * self.DSC\n return round(self._reusability, 5)","def calc_base_eff_and_infl(level):\n return 2 + (level - 1)","def rand_gen(below, baseline):\n\treturn secrets.randbelow(below)/ baseline","def set_display_trange(self, trang: float) -> None:\n self.write(':timebase:range {:.4g}'.format(trang))","def mask_percentage(self):\n return 100 - self.tissue_percentage","def Problem10():\n return 'When yield strength in tension and compression are not equal'","def sub_calculate_misms(my_line, misms):\n if misms == 0.0:\n gmism = tmism = cmism = amism = str(0.0)\n elif origbase == 'A':\n amism = str(0.0)\n gmism = str(float(int(my_line[7]) + int(my_line[12])) / misms)\n tmism = str(float(int(my_line[8]) + int(my_line[13])) / misms)\n cmism = str(float(int(my_line[9]) + int(my_line[14])) / misms)\n elif origbase == 'C':\n amism = str(float(int(my_line[6]) + int(my_line[11])) / misms)\n gmism = str(float(int(my_line[7]) + int(my_line[12])) / misms)\n tmism = str(float(int(my_line[8]) + int(my_line[13])) / misms)\n cmism = str(0.0)\n elif origbase == 'G':\n amism = str(float(int(my_line[6]) + int(my_line[11])) / misms)\n gmism = str(0.0)\n tmism = str(float(int(my_line[8]) + int(my_line[13])) / misms)\n cmism = str(float(int(my_line[9]) + int(my_line[14])) / misms)\n else:\n amism = str(float(int(my_line[6]) + int(my_line[11])) / misms)\n gmism = str(float(int(my_line[7]) + int(my_line[12])) / misms)\n tmism = str(0.0)\n cmism = str(float(int(my_line[9]) + int(my_line[14])) / misms)\n return amism, cmism, gmism, tmism","def validation_tpr_at_95tpr(self):\r\n\r\n return self.validation_tpr_at_confidence(self.confidence_at_tpr(0.95))","def get_gre_or_toefl(current_bucket_marks):\r\n\r\n computed_marks = current_bucket_marks.replace(\"\\n\", \"\").strip()\r\n try:\r\n int(computed_marks)\r\n return computed_marks\r\n except ValueError:\r\n return 0","def Init(self):\r\n print(\"Initiating...\")\r\n if (self.Get_FullScale_Value() == self.FullScaleEnum[0]):\r\n self.gain = 0.00875\r\n elif (self.Get_FullScale_Value() == self.FullScaleEnum[1]):\r\n self.gain = 0.0175\r\n elif (self.Get_FullScale_Value() == self.FullScaleEnum[2]):\r\n self.gain = 0.07\r\n print(\"Gain set to:{0}\".format(self.gain))","def mttr(self, down_time, failures=1, dec_point=3):\n self.down_time = down_time\n self.failures = failures\n self.dec_point = dec_point\n mt_tr = round(float(down_time / failures),dec_point)\n return mt_tr","def expected_result(self, other):\r\n return float(1) / (1 + math.pow(10, float(other.elo - self.elo) / DIVIDER))","def calc_pr_rc_F1(GTD, block_occ):\r\n true_pos = ((GTD + block_occ)==2).sum()\r\n false_pos = sum([1 if BI_val==1 and GTD[i]==0 else 0 for i, BI_val in enumerate(block_occ.values)])\r\n precision = float(true_pos/(true_pos+false_pos))\r\n recall = float(true_pos/(GTD.sum()))\r\n if precision == 0:\r\n F1 = 0\r\n else:\r\n F1 = float(2 * (precision * recall) / (precision + recall))\r\n \r\n return precision, recall, F1","def test_error_at_95tpr(self):\r\n\r\n return self.test_error_at_confidence(self.confidence_at_tpr(0.95))"],"string":"[\n \"def _getBaselineThresh(self):\\n print('Calculating 10% baseline')\\n self.baseline = obrienBaseline.obrienBaseline(\\n self.d['dos1rate'], timeWidth=5.0, \\n cadence=0.1)\\n self.peak_std = ( (self.d['dos1rate'][self.peakInd]/10 - \\n self.baseline[self.peakInd]/10)/ \\n np.sqrt(self.d['dos1rate'][self.peakInd]/10))\\n return\",\n \"def baseline_TVOC(self) -> int:\\n return self.get_iaq_baseline()[1]\",\n \"def evaluate_baseline(test_data):\\n\\n # create mapping xor diff -> biterrors \\n error_values = np.array([bin(x).count('1') for x in range(CONST_POINTS)]) \\n\\n x_raw, x = test_data\\n means = Data_generator().constellations[MODULATION][1]\\n x_recon = np.argmin(np.abs(x[:, None] - means[None, :]), axis=1)\\n\\n diff = x_recon^x_raw # bitwise comparison\\n bit_errors = np.sum(error_values[diff])\\n ber = bit_errors/(NUM_SAMPLES*BITS_PER_SYMBOL)\\n return ber\",\n \"def gtf(self):\\n\\t #if tank is empty, conductance is 0\\n\\t if self.tx <= 0:\\n\\t return 0.\\n\\t\\t#returns 0.5, as a function of TAI\\n\\t else:\\n\\t return 0.5\",\n \"def baseline_score(self,t0,t1):\\n return len(set(t0) & set(t1))/len(set(t0).union(set(t1)))\",\n \"def baseline(self):\\n return self.data[self.data['treatment'] == 'Baseline']\",\n \"def set_iaq_baseline( # pylint: disable=invalid-name\\n self, eCO2: int, TVOC: int\\n ) -> None:\\n if eCO2 == 0 and TVOC == 0:\\n raise RuntimeError(\\\"Invalid baseline\\\")\\n buffer = []\\n for value in [TVOC, eCO2]:\\n arr = [value >> 8, value & 0xFF]\\n arr.append(self._generate_crc(arr))\\n buffer += arr\\n self._run_profile((\\\"iaq_set_baseline\\\", [0x20, 0x1E] + buffer, 0, 0.01))\",\n \"def baseline(ant_ID1, ant_ID2):\\n return ant_pos[ant_ID2] - ant_pos[ant_ID1]\",\n \"def find_gains_for_baseline(self, t, bl):\\n\\n ant1, ant2 = baselines_2_ants([bl])\\n\\n # Find indx of gains entries containing ``t`` with ant1 & ant2\\n indx1 = np.where((t <= self._data['stop']) & (t >= self._data['start'])\\n & (self._data['antenna'] == ant1))[0]\\n indx2 = np.where((t <= self._data['stop']) & (t >= self._data['start'])\\n & (self._data['antenna'] == ant2))[0]\\n\\n # Now each gains# has shape (#if, #pol)\\n gains1 = np.squeeze(self._data[indx1]['gains'])\\n gains2 = np.squeeze(self._data[indx2]['gains'])\\n\\n # ``gains12`` has shape (#stokes, #nif)\\n gains12 = np.asarray([gains1[:, 0] * np.conjugate(gains2[:, 0]),\\n gains1[:, 1] * np.conjugate(gains2[:, 1]),\\n gains1[:, 0] * np.conjugate(gains2[:, 1]),\\n gains1[:, 1] * np.conjugate(gains2[:, 0])])\\n\\n return gains12\",\n \"def test_calculate_tutor_baseline(self):\\n tmax = 40.0\\n dt = 1.0\\n ini_rate = 80.0\\n baseline_n = 5\\n\\n rate1 = ini_rate + 20.0\\n rate2 = ini_rate - 10.0\\n\\n nruns = 10\\n nsteps = int_r(tmax/dt)\\n\\n tutor = SimpleNeurons(2, out_fct=lambda i:\\n [rate1, rate2] if i < nsteps/2 else [rate2, rate1])\\n reward = MockReward(lambda _: 0.0)\\n tutor_rule = ReinforcementTutorRule(tutor, reward, tau=0,\\n constrain_rates=False, ini_rate=ini_rate, learning_rate=0.1,\\n use_tutor_baseline=True, baseline_n=baseline_n)\\n\\n factor = 1 - 1.0/baseline_n\\n\\n for i in xrange(nruns):\\n tutor_rule.reset_rates()\\n\\n sim = simulation.Simulation(tutor, reward, tutor_rule, dt=dt)\\n sim.run(tmax)\\n\\n crt_baseline = tutor_rule.baseline\\n\\n self.assertEqual(np.ndim(crt_baseline), 2)\\n self.assertEqual(np.shape(crt_baseline)[0], nsteps)\\n self.assertEqual(np.shape(crt_baseline)[1], 2)\\n\\n expected1 = rate1 + (ini_rate - rate1)*factor**(i+1)\\n expected2 = rate2 + (ini_rate - rate2)*factor**(i+1)\\n\\n self.assertLess(np.max(np.abs(crt_baseline[:nsteps/2, 0] - expected1)),\\n 1e-6)\\n self.assertLess(np.max(np.abs(crt_baseline[nsteps/2:, 0] - expected2)),\\n 1e-6)\\n\\n self.assertLess(np.max(np.abs(crt_baseline[:nsteps/2, 1] - expected2)),\\n 1e-6)\\n self.assertLess(np.max(np.abs(crt_baseline[nsteps/2:, 1] - expected1)),\\n 1e-6)\",\n \"def test_no_backg_subt():\\n \\n test_object = fa.read_in_envision(data_csv=HsHis6_PEX5C_vs_HsPEX5C, platemap_csv=Hs_His6_PEX5C_vs_HsPEX5C_platemap, data_type='plate', size=384)\\n test_object.calculate_r_i(correct=True, plot_i=False, thr=80)\",\n \"def rec_default(self):\\n self.phase_triggers.setText('(0,1,320)')\\n self.phase_min.setText('-1.57')\\n self.phase_max.setText('1.57')\",\n \"def SuperTrend(df, period, multiplier, ohlc=['open', 'high', 'low', 'close']):\\n\\n ATR(df, period, ohlc=ohlc) \\n atr = 'ATR_' + str(period) \\n st = 'ST_' + str(period) + '_' + str(multiplier) \\n stx = 'STX_' + str(period) + '_' + str(multiplier) \\n \\\"\\\"\\\" \\n SuperTrend Algorithm : \\n BASIC UPPERBAND = (HIGH + LOW) / 2 + Multiplier * ATR \\n BASIC LOWERBAND = (HIGH + LOW) / 2 - Multiplier * ATR \\n FINAL UPPERBAND = IF( (Current BASICUPPERBAND < Previous FINAL UPPERBAND) or (Previous Close > Previous FINAL UPPERBAND)) \\n THEN (Current BASIC UPPERBAND) ELSE Previous FINALUPPERBAND) \\n FINAL LOWERBAND = IF( (Current BASIC LOWERBAND > Previous FINAL LOWERBAND) or (Previous Close < Previous FINAL LOWERBAND)) \\n THEN (Current BASIC LOWERBAND) ELSE Previous FINAL LOWERBAND) \\n SUPERTREND = IF((Previous SUPERTREND = Previous FINAL UPPERBAND) and (Current Close <= Current FINAL UPPERBAND)) THEN \\n Current FINAL UPPERBAND \\n ELSE \\n IF((Previous SUPERTREND = Previous FINAL UPPERBAND) and (Current Close > Current FINAL UPPERBAND)) THEN \\n Current FINAL LOWERBAND \\n ELSE \\n IF((Previous SUPERTREND = Previous FINAL LOWERBAND) and (Current Close >= Current FINAL LOWERBAND)) THEN \\n Current FINAL LOWERBAND \\n ELSE \\n IF((Previous SUPERTREND = Previous FINAL LOWERBAND) and (Current Close < Current FINAL LOWERBAND)) THEN \\n Current FINAL UPPERBAND \\n \\\"\\\"\\\" \\n # Compute basic upper and lower bands \\n df['basic_ub'] = (df[ohlc[1]] + df[ohlc[2]]) / 2 + multiplier * df[atr] \\n df['basic_lb'] = (df[ohlc[1]] + df[ohlc[2]]) / 2 - multiplier * df[atr]\\n\\n # Compute final upper and lower bands \\n df['final_ub'] = 0.00 \\n df['final_lb'] = 0.00 \\n for i in range(period, len(df)): \\n df['final_ub'].iat[i] = df['basic_ub'].iat[i] if df['basic_ub'].iat[i] < df['final_ub'].iat[i - 1] or df['Close'].iat[i - 1] > df['final_ub'].iat[i - 1] else df['final_ub'].iat[i - 1] \\n df['final_lb'].iat[i] = df['basic_lb'].iat[i] if df['basic_lb'].iat[i] > df['final_lb'].iat[i - 1] or df['Close'].iat[i - 1] < df['final_lb'].iat[i - 1] else df['final_lb'].iat[i - 1] \\n # Set the Supertrend value \\n df[st] = 0.00 \\n for i in range(period, len(df)): \\n df[st].iat[i] = df['final_ub'].iat[i] if df[st].iat[i - 1] == df['final_ub'].iat[i - 1] and df['Close'].iat[i] <= df['final_ub'].iat[i] else 0\\n df['final_lb'].iat[i] if df[st].iat[i - 1] == df['final_ub'].iat[i - 1] and df['Close'].iat[i] > df['final_ub'].iat[i] else 0\\n df['final_lb'].iat[i] if df[st].iat[i - 1] == df['final_lb'].iat[i - 1] and df['Close'].iat[i] >= df['final_lb'].iat[i] else 0\\n df['final_ub'].iat[i] if df[st].iat[i - 1] == df['final_lb'].iat[i - 1] and df['Close'].iat[i] < df['final_lb'].iat[i] else 0.00 \\n # Mark the trend direction up/down \\n df[stx] = np.where((df[st] > 0.00), np.where((df[ohlc[3]] < df[st]), 'down', 'up'), np.NaN)\\n\\n # Remove basic and final bands from the columns \\n df.drop(['basic_ub', 'basic_lb', 'final_ub', 'final_lb'], inplace=True, axis=1) \\n df.fillna(0, inplace=True)\\n\\n return df\",\n \"def baseline(data):\\n weights = weighting(data)\\n return np.inner(weights,data['clicks'])/weights.sum()\",\n \"def PG_baseline(self, p, w, tau):\\n tau = np.array(tau)\\n T = len(tau)\\n A = tau[:, 1]\\n R = tau[:, 2]\\n\\n prob = p\\n base = w\\n estG = self.estG(R, self.gamma, T)\\n\\n delta = estG - self.value(base)\\n\\n for t in range(T):\\n base += self.alphabase * delta[t] * self.dval(base)\\n prob += self.alpha * self.gamma**t * delta[t] * self.gradient(prob, A[t])\\n\\n return prob, base\",\n \"def fGT(self):\\n pass\",\n \"def calc_pre_intertie_generation (self):\\n\\n self.pre_intertie_generation = \\\\\\n self.forecast.get_generation(self.start_year,self.end_year)\\n\\n gen_eff = self.cd[\\\"diesel generation efficiency\\\"]\\n self.pre_intertie_generation_fuel_used = \\\\\\n self.pre_intertie_generation / gen_eff\\n\\n #~ print 'self.baseline_generatio',self.baseline_generation\",\n \"def baseline(self):\\n if getattr(self, \\\"_baseline\\\", None) is None:\\n self._baseline = (self.container.height - 1) / 2\\n return self._baseline\",\n \"def test_calculate_tst_rate_coefficient(self):\\n self.assertEqual(\\\"%0.7f\\\" % self.kineticsjob.reaction.calculate_tst_rate_coefficient(self.TminValue),\\n str(46608.5904933))\\n self.assertEqual(\\\"%0.5f\\\" % self.kineticsjob.reaction.calculate_tst_rate_coefficient(self.Tmaxvalue),\\n str(498796.64535))\",\n \"def test_GBL_tau_inst():\\n dz = 0.05\\n z = numpy.arange(0., 80. + 1.5*dz, dz)\\n\\n # Fully ionized H and He\\n x_ionH = 1.0\\n x_ionHe = 2.0\\n\\n cosmo = {}\\n cosmo['omega_M_0'] = numpy.array([[0.3],[0.6],[1.0]])\\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\\n cosmo['h'] = 0.65\\n cosmo['omega_b_0'] = 0.02 / cosmo['h']**2.\\n cosmo['Y_He'] = 0.24\\n cd.set_omega_k_0(cosmo)\\n\\n tau_inst = cr.optical_depth_instant(z, x_ionH=x_ionH, x_ionHe=x_ionHe, \\n **cosmo)\\n tau_int = cr.integrate_optical_depth(x_ionH, x_ionHe, z, **cosmo)\\n\\n linestyle = ['-', ':', '--']\\n \\n pylab.figure()\\n pylab.subplot(2,1,1)\\n pylab.title(\\\"Compare to GB&L fig. 1 (astro-ph/9812125v3.)\\\")\\n for i in range(len(linestyle)):\\n pylab.plot(z, tau_inst[i], ls=linestyle[i], color='b')\\n pylab.plot(z, tau_int[i], ls=linestyle[i], color='r')\\n\\n pylab.xlim(0,80)\\n pylab.ylim(0,1)\\n pylab.xlabel(r\\\"$\\\\mathrm{z_{ion}}$\\\")\\n pylab.ylabel(r\\\"$\\\\tau$\\\")\\n \\n pylab.subplot(2,1,2)\\n for i in range(len(linestyle)):\\n pylab.plot(z, \\n 1.e4 * (tau_int[i] - tau_inst[i])/tau_inst[i], \\n ls=linestyle[i], color='k')\\n diff = (tau_int[i] - tau_inst[i]) / tau_inst[i]\\n diff[numpy.isnan(diff)] = 0.0\\n print(\\\"max fractional error in num. int. = %.3g\\\" % \\n numpy.max(numpy.abs(diff))\\n )\\n ntest.assert_array_less(numpy.abs(diff), \\n numpy.zeros(diff.shape) + 2.e-4)\\n\\n pylab.xlim(0,40)\\n pylab.xlabel(r\\\"$\\\\mathrm{z_{ion}}$\\\")\\n pylab.ylabel(r\\\"$\\\\mathrm{10^4 \\\\times (num.\\\\tau - ana.\\\\tau)/ana.\\\\tau}$\\\")\",\n \"def test_use_tutor_baseline(self):\\n tmax = 40.0\\n dt = 1.0\\n ini_rate = 80.0\\n\\n nruns = 11\\n\\n tutor = SimpleNeurons(2, out_fct=lambda _: [100.0, 60.0])\\n reward = MockReward(lambda t: 1.0 if t < tmax/2 else -1)\\n tutor_rule = ReinforcementTutorRule(tutor, reward, tau=0,\\n constrain_rates=False, ini_rate=ini_rate, learning_rate=0.1)\\n\\n tutor_rule.use_tutor_baseline = True\\n tutor_rule.baseline_n = 5\\n\\n for i in xrange(nruns):\\n # we first set the baselines for the two neurons to some values different\\n # from tutor_rule's ini_rate, and then in the last round, we test how the\\n # rates change\\n if i == nruns-1:\\n tutor.out_fct = lambda _: [80.0, 80.0]\\n\\n tutor_rule.reset_rates()\\n\\n sim = simulation.Simulation(tutor, reward, tutor_rule, dt=dt)\\n sim.run(tmax)\\n\\n drates = tutor_rule.rates - ini_rate\\n\\n # for the first neuron, for t < tmax/2, the current firing rate is below the\\n # baseline and the reward is positive, so the rates should *decrease*\\n # for t >= tmax/2, the rates should *increase*\\n # the opposite should happen for the second neuron\\n mask = (np.arange(0, tmax, dt) < tmax/2)\\n\\n self.assertGreater(np.min(drates[mask, 1]), 0)\\n self.assertLess(np.max(drates[mask, 0]), 0)\\n\\n self.assertGreater(np.min(drates[~mask, 0]), 0)\\n self.assertLess(np.max(drates[~mask, 1]), 0)\",\n \"def test_coded_freq(self):\\n self.assertAlmostEqual(self.g.coded_freq(), 10 / 18)\",\n \"def acc_b_tr(self):\\r\\n return self._acc_b_tr\",\n \"def test_xx1_thr(self):\\n u_spec = leabra.UnitSpec()\\n u_spec.act_thr = 0.25\\n u = leabra.Unit(spec=u_spec)\\n self.assertEqual(u_spec.xx1(-0.1), 0.0)\\n self.assertTrue(0.0 < u_spec.xx1(0.1))\\n self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)\\n self.assertTrue(0.1 < u_spec.noisy_xx1(0.1))\",\n \"def baseline_correction(df, pup_col, time_col, baseline_range, method='subtractive'):\\r\\n \\r\\n if method not in ['subtractive','divisive']:\\r\\n raise Exception(\\\"Invalid baseline correction method. Please use 'subtractive' or 'divisive'.\\\")\\r\\n \\r\\n bl_mean = df.loc[(df[time_col] >= baseline_range[0]) & (df[time_col] < baseline_range[1])][pup_col].median()\\r\\n \\r\\n if method == 'subtractive':\\r\\n df[pup_col+'_bsl'] = df[pup_col] - bl_mean\\r\\n \\r\\n elif method == 'divisive':\\r\\n df[pup_col+'_bsl'] = df[pup_col]/bl_mean\\r\\n \\r\\n return df\",\n \"def validation_tpr_at_98tpr(self):\\r\\n\\r\\n return self.validation_tpr_at_confidence(self.confidence_at_tpr(0.98))\",\n \"def evalBaseline(self, df = None):\\n \\n if (df is None):\\n self.r_b = self.df.merge(self.df_user[[\\\"user ind\\\", \\\"b_u\\\"]], on = \\\"user ind\\\")\\n self.r_b = self.r_b.merge(self.df_item[[\\\"item ind\\\", \\\"b_i\\\"]], on = \\\"item ind\\\")\\n self.r_b[\\\"baseline\\\"] = self.r_mean + self.r_b[\\\"b_u\\\"] + self.r_b[\\\"b_i\\\"]\\n \\n \\n return self.r_b[[\\\"user id\\\", \\\"item id\\\", \\\"baseline\\\"]]\\n \\n else:\\n df = df.merge(self.df_user, on = \\\"user id\\\").merge(self.df_item, on = \\\"item id\\\")\\n df[\\\"baseline\\\"] = self.r_mean + df[\\\"b_u\\\"] + df[\\\"b_i\\\"]\\n \\n # clip the score to the interval [1, 5]\\n df[\\\"baseline\\\"] = np.minimum(np.maximum(df[\\\"baseline\\\"], 1), 5)\\n \\n return df[[\\\"user id\\\", \\\"item id\\\", \\\"baseline\\\"]]\",\n \"def work(char, base, scale_stat, factor):\\n added = int(math.floor(char.__dict__[scale_stat] / factor))\\n earned = base + added\\n return [(\\\"gold\\\", earned)]\",\n \"def baseline_eCO2(self) -> int:\\n return self.get_iaq_baseline()[0]\",\n \"def baselineFrames(self):\\n frames=[]\\n for tag,T1,T2 in [x for x in self.tags if x[0]=='baseline']:\\n for i,timePoint in enumerate(self.conf['times']):\\n if timePoint>=T1*60 and timePoint<=T2*60:\\n frames.append(i)\\n return frames\\n else:\\n return [0]\",\n \"def gtVcf(ref, alt, gt):\\n\\tif gt == ref: return \\\"0\\\"\\n\\tif gt == alt: return \\\"1\\\"\\n\\treturn \\\".\\\"\",\n \"def _get_tr(cls, data):\\n\\t\\tprev_close = data['close_-1_s']\\n\\t\\thigh = data['high']\\n\\t\\tlow = data['low']\\n\\t\\tc1 = high - low\\n\\t\\tc2 = np.abs(high - prev_close)\\n\\t\\tc3 = np.abs(low - prev_close)\\n\\t\\tdata['tr'] = np.max((c1, c2, c3), axis=0)\",\n \"def test_gtf(self):\\n #TODO write bed tests\",\n \"def baseline(*args):\\n XTrain, XTest, yTrain, yTest = args\\n clf = DecisionTreeClassifier(random_state=42)\\n clf.fit(XTrain, yTrain)\\n return clf.score(XTest, yTest), clf.feature_importances_\",\n \"def getETA():\",\n \"def getETA():\",\n \"def get_gains(self):\\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x8000+i,0)/100 for i in range(4)])\",\n \"def __init__(self):\\n super().__init__()\\n self.TERRAIN_VARIANCE = 0.0\",\n \"def _baseline_value(self):\\n t = self['primary']\\n return np.median(t.data[:int(10e-3/t.dt)])\",\n \"def okapiTF(self, tf, dlen, avgdlen):\\n return tf / (tf + 0.5 + 1.5 * (dlen/avgdlen))\",\n \"def T1_contrast():\\n t = np.linspace(0, 10000, 10000)\\n s1 = MZ(t, 200, 900)\\n s2 = MZ(t, 200, 1200)\\n r = np.argmax(s1 - s2)\\n print(f\\\"{r:.2f}\\\")\\n plt.plot(t, s1, label=\\\"White matter\\\")\\n plt.plot(t, s2, label=\\\"Grey matter\\\")\\n plt.legend()\\n plt.show()\",\n \"def coverage(self):\\r\\n return 0, 1\",\n \"def claim_document_baseline():\\n param_range = namedtuple('param_range','start, end')\\n alpha_settings = param_range(0,1)#,param_range(10,11)\\n beta_settings = param_range(0,1)#,param_range(9,10)] #as it finished at beta=0.9\\n lambda_settings = param_range(0,11)\\n \\n claim_document_baseline_LOO(alpha_settings,beta_settings,lambda_settings)\",\n \"def tGain(self, dt, r):\\n\\t return 1./(10.**6)*r#*precip.r\",\n \"def front_column_model_p_gain():\",\n \"def test_error_at_98tpr(self):\\r\\n\\r\\n return self.test_error_at_confidence(self.confidence_at_tpr(0.98))\",\n \"def get_iaq_baseline(self) -> List[int]:\\n # name, command, signals, delay\\n return self._run_profile((\\\"iaq_get_baseline\\\", [0x20, 0x15], 2, 0.01))\",\n \"def testbaselinelc(self):\\n a_in = os.path.join(self.datadir,\\n 'monol_testA_E3-50_lc' + HEN_FILE_EXTENSION)\\n out = os.path.join(self.datadir, 'monol_test_baselc')\\n command = '{0} -o {1} -p 0.001 --lam 1e5'.format(a_in, out)\\n\\n hen.lcurve.baseline_main(command.split())\\n out_lc = hen.io.load_lcurve(out + '_0' + HEN_FILE_EXTENSION)\\n assert hasattr(out_lc, 'base')\\n gti_to_test = hen.io.load_events(self.first_event_file).gti\\n assert np.allclose(gti_to_test, out_lc.gti)\",\n \"def tpr_at_98tpr(self):\\r\\n\\r\\n return self.tpr_at_confidence(self.confidence_at_tpr(0.98))\",\n \"def plot_tuning_curves(self, baseline_rate=10.):\\n x = np.arange(0, 1 + 0.01, 0.01)\\n l0 = self.data['L0']\\n l1 = self.data['L1']\\n y_on = np.exp(np.log(l0) + x * np.log(l1 / l0))\\n y_off = np.exp(np.log(l0) + (1 - x) * np.log(l1 / l0))\\n plt.plot(x, y_on, label='ON')\\n plt.plot(x, y_off, label='OFF')\\n plt.plot(x, baseline_rate + 0 * x, '--')\\n # plt.xlabel('Stimulus intensity')\\n # plt.ylabel('Firing Rate (Hz)')\\n # plt.title('Firing rate as a function \\\\n of Stimulus Intensity')\\n # plt.legend()\",\n \"def all_baselines():\\n for i in range(len(active_ants)):\\n ID1 = active_ants[i]\\n for j in range(i + 1, len(active_ants[i + 1:])):\\n ID2 = active_ants[j]\\n print(\\\"Baseline between antennae \\\" + str(ID1) + \\\\\\n \\\" and \\\" + str(ID2) + \\\" = \\\" + str(ant.baseline(ID1, ID2)))\",\n \"def __get_change(self, current, previous):\\n current = float(current)\\n previous = float(previous)\\n if current == previous:\\n return 0\\n try:\\n r = (abs(current - previous) / previous) * 100\\n if r > 100:\\n r = 100\\n return round(r)\\n except ZeroDivisionError:\\n return 100\",\n \"def prescaler(self) -> int:\",\n \"def compare_strategies(strategy, baseline=always_roll(5)):\\r\\n as_first = 1 - make_average(play)(strategy, baseline)\\r\\n as_second = make_average(play)(baseline, strategy)\\r\\n return (as_first + as_second) / 2 # Average the two results\\r\",\n \"def baseline(spectra):\\n\\n return spectra - np.mean(spectra, axis=0)\",\n \"def baseline_total_organic_compound(self):\\n return self.indoor_air_quality_baseline[1]\",\n \"def preferred_vertical_rate(self):\\n pref_code = (self._block[2] >> 5) & 0x03 # Ranges 00-11 (0-3)\\n supp_code = self._block[2] & 0x1F # 5 bits long\\n\\n if pref_code == 0x01 and supp_code & 0x01:\\n pref_code = 4\\n return self._ref_rates[pref_code][1]\",\n \"def set_defensive_ratio(self):\\n bx = self.get_standard_stats()\\n team = self.get_team_stats()\\n opp_team = self.get_opp_team_stats()\\n if bx[\\\"minutes\\\"] > 0:\\n opp_fga = opp_team[\\\"t2p_int\\\"] + opp_team[\\\"t3p_int\\\"]\\n opp_fgm = opp_team[\\\"t2p_conv\\\"] + opp_team[\\\"t3p_conv\\\"]\\n try:\\n dor = Decimal(opp_team[\\\"reb_of\\\"] / (opp_team[\\\"reb_of\\\"] + team[\\\"reb_def\\\"]))\\n except ZeroDivisionError:\\n print(BCOLORS.FAIL + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n dor = 0\\n except InvalidOperation:\\n print(BCOLORS.FAIL + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n dor = 0\\n\\n try:\\n dfg = Decimal(opp_fgm / opp_fga)\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n dfg = 0\\n try:\\n fmwt = Decimal((dfg * (1 - dor)) / (dfg * (1 - dor) + (1 - dfg) * dor))\\n except:\\n fmwt = 0\\n stops1 = bx[\\\"steals\\\"] + bx[\\\"block_shots\\\"] * fmwt * (1 - Decimal('1.07') * dor) + bx[\\\"reb_def\\\"] * (1 - fmwt)\\n\\n try:\\n stops2 = (Decimal((opp_fga - opp_fgm - team[\\\"block_shots\\\"]) / team[\\\"minutes\\\"]) * fmwt * (1 - Decimal('1.07') * dor) + Decimal((opp_team[\\\"turnovers\\\"] - team[\\\"steals\\\"]) / team[\\\"minutes\\\"])) * bx[\\\"minutes\\\"] + Decimal(bx[\\\"fouls_cm\\\"] / team[\\\"fouls_cm\\\"]) * Decimal('0.4') * opp_team[\\\"tl_int\\\"] * (1 - Decimal(opp_team[\\\"tl_conv\\\"] / opp_team[\\\"tl_int\\\"]))**2\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n stops2 = 0\\n except InvalidOperation:\\n print(BCOLORS.WARNING + \\\"Error: Invalid Operation\\\" + BCOLORS.ENDC)\\n stops2 = 0\\n\\n stops = stops1 + stops2\\n poss = self.get_team_possessions()\\n if bx[\\\"minutes\\\"] > 0:\\n stop_percentage = (float(stops) * float(opp_team[\\\"minutes\\\"])) / (float(poss) * float(bx[\\\"minutes\\\"]))\\n else:\\n stop_percentage = 0.00\\n opp_points = opp_team[\\\"t2p_conv\\\"] * 2 + opp_team[\\\"t3p_conv\\\"] * 3 + opp_team[\\\"tl_conv\\\"]\\n team_defensive_rating = 100 * (float(opp_points) / poss)\\n try:\\n d_pts_per_scposs = float(opp_points) / (float(opp_fgm) + (1 - (1 - (float(opp_team[\\\"tl_conv\\\"]) / float(opp_team[\\\"tl_int\\\"])))**2) * float(opp_team[\\\"tl_int\\\"])*0.4)\\n result = Decimal(team_defensive_rating) + Decimal('0.2') * (100 * Decimal(d_pts_per_scposs) * (1 - Decimal(stop_percentage)) - Decimal(team_defensive_rating))\\n except ZeroDivisionError:\\n print(BCOLORS.WARNING + \\\"Error: División por cero\\\" + BCOLORS.ENDC)\\n d_pts_per_scposs = 0\\n result = 0.00\\n\\n\\n\\n # print(\\\"dor: \\\" + str(dor))\\n # print(\\\"dfg: \\\" + str(dfg))\\n # print(\\\"fmwt: \\\" + str(fmwt))\\n # print(\\\"stops1: \\\" + str(stops1))\\n # print(\\\"stops2: \\\" + str(stops2))\\n # print(\\\"stops: \\\" + str(stops))\\n # print(\\\"poss: \\\" + str(poss))\\n # print(\\\"stop_percentage: \\\" + str(stop_percentage))\\n # print(\\\"opp_points: \\\" + str(opp_points))\\n # print(\\\"team_defensive_rating: \\\" + str(team_defensive_rating))\\n # print(\\\"d_pts_per_scposs: \\\" + str(d_pts_per_scposs))\\n # print(\\\"drtg: \\\" + str(result) + \\\"\\\\n\\\")\\n else:\\n result = 0.00\\n self.drtg = \\\"%.2f\\\" % round(result, 2)\",\n \"def baseline_co2_equivilant(self):\\n return self.indoor_air_quality_baseline[0]\",\n \"def get_max_gains(self):\\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x800c+i,100)/100 for i in range(4)])\",\n \"def learning_rate_range():\\n # Lower and upper bounds\\n #######\\n lower_bound = 0.1 \\n upper_bound = 1e-6\\n #######\\n return lower_bound, upper_bound\",\n \"def get_rec_rate_H_caseB(T):\\n Tinv = 1.0/T\\n bb = 315614.0*Tinv\\n cc = 115188.0*Tinv\\n dd = 1.0 + np.power(cc, 0.407)\\n return 2.753e-14*np.power(bb, 1.5)*np.power(dd, -2.242)\",\n \"def dbgain(self, pt_1, pt_2):\\n raise NotImplementedError\",\n \"def tickDiff(tStart, tEnd):\\n tDiff = tEnd - tStart\\n if tDiff < 0:\\n tDiff += (1 << 32)\\n return tDiff\",\n \"def _rms_sort(self):\\n if self.image_status == 'match':\\n return \\\"000000\\\"\\n elif self.image_status == 'diff':\\n if self.rms is None: # Shape mismatch\\n return \\\"999999\\\"\\n # RMS will be in [0, 255]\\n return f\\\"{(self.rms + 2) * 1000:06.0f}\\\"\\n else: # Missing baseline image\\n return \\\"000001\\\"\",\n \"def test_decaydata_branching_fraction(self):\\n\\n data = decaydata.DecayData(\\\"icrp107\\\")\\n self.assertEqual(data.branching_fraction(\\\"K-40\\\", \\\"Ca-40\\\"), 0.8914)\\n self.assertEqual(data.branching_fraction(\\\"K-40\\\", \\\"H-3\\\"), 0.0)\",\n \"def g(self):\\n return 2\",\n \"def TVOC(self) -> int:\\n return self.iaq_measure()[1]\",\n \"def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\\n total_days=df.shape[0]\\n today_invt_dict=invt_dict\\n invt_daily_list=[] # invt after today's transaction\\n net_wealth_list=[]\\n\\n for i in range(total_days):\\n if i==0:\\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\\n elif i==total_days-1: # last day\\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\\n invt_daily_list.append(today_invt_dict)\\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\\n \\n PrintResult(\\\"Baseline Strategy\\\", net_wealth_list)\\n plt.plot(net_wealth_list)\\n plt.title(\\\"Baseline (1st day buy->hold->last day sell) Strategy\\\")\\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\\n plt.show()\\n return\",\n \"def indoor_air_quality_baseline(self):\\n # name, command, signals, delay\\n return self._i2c_read_words_from_cmd(command=[0x20, 0x15], reply_size=2, delay=0.01)\",\n \"def baseline_deviation_2_rule(_m, y):\\r\\n\\r\\n if y == m.Y.first():\\r\\n return Constraint.Skip\\r\\n else:\\r\\n return m.z_b2[y] >= m.baseline[y - 1] - m.baseline[y]\",\n \"def correct_baseline(trace, config=None):\\n if config is None:\\n config = get_config()\\n\\n # Integrate twice to get the displacement time series\\n disp_data = get_disp(trace, method=config[\\\"integration\\\"][\\\"method\\\"])\\n\\n # Fit a sixth order polynomial to displacement time series, requiring\\n # that the 1st and 0th order coefficients are zero\\n time_values = (\\n np.linspace(0, trace.stats.npts - 1, trace.stats.npts) * trace.stats.delta\\n )\\n poly_cofs = list(curve_fit(_poly_func, time_values, disp_data)[0])\\n poly_cofs += [0, 0]\\n\\n # Construct a polynomial from the coefficients and compute\\n # the second derivative\\n polynomial = np.poly1d(poly_cofs)\\n polynomial_second_derivative = np.polyder(polynomial, 2)\\n\\n # Subtract the second derivative of the polynomial from the\\n # acceleration trace\\n trace.data -= polynomial_second_derivative(time_values)\\n trace.setParameter(\\\"baseline\\\", {\\\"polynomial_coefs\\\": poly_cofs})\\n\\n return trace\",\n \"def set_dre(self):\\n bx = self.get_standard_stats()\\n ptos = float(bx[\\\"t2p_conv\\\"]*2 + bx[\\\"t3p_conv\\\"]*3 + bx[\\\"tl_conv\\\"])\\n fga = float(bx[\\\"t2p_int\\\"] + bx[\\\"t3p_int\\\"])\\n trb = float(bx[\\\"reb_def\\\"] + bx[\\\"reb_of\\\"])\\n d1 = ptos + (0.2*trb) + (1.7*float(bx[\\\"steals\\\"])) + (0.535*float(bx[\\\"block_shots\\\"])) + (0.5*float(bx[\\\"assists\\\"]))\\n d2 = (0.9*fga) + (0.35*float(bx[\\\"tl_int\\\"])) + (1.4*float(bx[\\\"turnovers\\\"])) + (0.136*float(bx[\\\"minutes\\\"]))\\n result = \\\"%.2f\\\" % round(d1-d2, 2)\\n self.dre = \\\"%.2f\\\" % round(Decimal(result)/bx[\\\"games\\\"], 2)\",\n \"def tweak(rg):\\n (r, g) = rg\\n if r == 0 and g == 0:\\n return 0, 0\\n elif r == 1 and g == 1:\\n return 2, 2\\n elif r == 0:\\n if g == 1:\\n g += 1\\n else:\\n g -= 1\\n elif g == 0:\\n if r == 1:\\n r += 1\\n else:\\n r -= 1\\n else:\\n r -= 1\\n g -= 1\\n return r, g\",\n \"def proz(): \\r\\n print(\\\"processing: \\\",CURDATA()[0]) \\r\\n Check_180turn(left_boundary,right_boundary)\\r\\n EF() #exponential window multiplication + fourier\\r\\n APK0() #1. Phase correction 0th Ordnung\\r\\n APK1() #1. Phase correction 1st Ordnung\\r\\n ABS() #Baseline correction\\r\\n APK()\\r\\n ABS() #Baseline correction\\r\\n Check_180turn(left_boundary,right_boundary)\",\n \"def brate(self):\\n try:\\n return self.pos / self.runtime\\n except ZeroDivisionError:\\n return 0\",\n \"def calc_HEX_mix(Q1, Q2, t1, m1, t2, m2):\\n if Q1 > 0 or Q2 > 0:\\n tavg = (t1 * m1 + t2 * m2) / (m1 + m2)\\n else:\\n tavg = 0\\n return np.float(tavg)\",\n \"def supervised_baseline(self, supervised_decoder):\\r\\n supervised_decoder_pred, _, baseline_reward = sm.validationMetricPerformance(\\r\\n input_pairs=[(self.source_sentence, self.target_sentence)], encoder=self.supervised_encoder,\\r\\n decoder=supervised_decoder, similarity_model=self.similarity_model, fluency_model=self.fluency_model,\\r\\n ESIM_model=self.ESIM_model, logr_model=self.logr_model, std_scaler=self.std_scaler,\\r\\n similarity_dist=self.similarity_dist, fluency_dist=self.fluency_dist, ESIM_dist=self.ESIM_dist,\\r\\n vocab_index=vocab_index, verbose=False, metric=self.reward_function)\\r\\n \\r\\n supervised_decoder_pred = supervised_decoder_pred[0][1]\\r\\n \\r\\n return supervised_decoder_pred, np.around(baseline_reward, 3)\",\n \"def get_fare(self):\\r\\n return super().get_fare()*self.fanciness_rating+self.flagfall\",\n \"async def decide(self):\\n return 0., 0., 0.\",\n \"def convert_flowrate(setting):\\r\\n return 0.8991*setting - 62.339\",\n \"def b_vs_r(r, t=.97):\\n min_b = (np.log(1-t))/(np.log(1-.95**r))\\n return min_b\",\n \"def functionality(self):\\n self._functionality = 0.12 * self.CAMC + 0.22 * self.NOP + 0.22 * self.CIS + 0.22 * self.DSC + 0.22 * self.NOH\\n return round(self._functionality, 5)\",\n \"def fixed_baseline(random_seeds, train_data, test_data):\\n\\n err = 0.\\n\\n for seed in random_seeds:\\n np.random.seed(seed)\\n\\n data = prep_data(train_data, test_data)\\n\\n wrong = 0.\\n for i in range(data['test_rows']):\\n if not data['test_ys'][i] == 1.0:\\n wrong += 1\\n\\n err += wrong / data['test_rows']\\n\\n return err / len(random_seeds)\",\n \"def __call__(self,t=0):\\n\\n return (self.g(t) if (t<self.tc) else self.itpr(t))\",\n \"def bad_start_rate(labelled,str):\\n#\\tlabelled = RawClaim.objects.exclude(correcttrim=\\\"\\\")\\n\\tfiltered = set([l for l in labelled if fixstring(l.sentence).startswith(str)])\\n\\twrong = set([l for l in filtered if l.correcttrim!=\\\"X\\\"])\\n\\tright = filtered - wrong\\n\\treturn (float(len(right))/len(filtered),wrong,right)\",\n \"def reusability(self):\\n self._reusability = -0.25 * self.DCC + 0.25 * self.CAMC + 0.5 * self.CIS + 0.5 * self.DSC\\n return round(self._reusability, 5)\",\n \"def calc_base_eff_and_infl(level):\\n return 2 + (level - 1)\",\n \"def rand_gen(below, baseline):\\n\\treturn secrets.randbelow(below)/ baseline\",\n \"def set_display_trange(self, trang: float) -> None:\\n self.write(':timebase:range {:.4g}'.format(trang))\",\n \"def mask_percentage(self):\\n return 100 - self.tissue_percentage\",\n \"def Problem10():\\n return 'When yield strength in tension and compression are not equal'\",\n \"def sub_calculate_misms(my_line, misms):\\n if misms == 0.0:\\n gmism = tmism = cmism = amism = str(0.0)\\n elif origbase == 'A':\\n amism = str(0.0)\\n gmism = str(float(int(my_line[7]) + int(my_line[12])) / misms)\\n tmism = str(float(int(my_line[8]) + int(my_line[13])) / misms)\\n cmism = str(float(int(my_line[9]) + int(my_line[14])) / misms)\\n elif origbase == 'C':\\n amism = str(float(int(my_line[6]) + int(my_line[11])) / misms)\\n gmism = str(float(int(my_line[7]) + int(my_line[12])) / misms)\\n tmism = str(float(int(my_line[8]) + int(my_line[13])) / misms)\\n cmism = str(0.0)\\n elif origbase == 'G':\\n amism = str(float(int(my_line[6]) + int(my_line[11])) / misms)\\n gmism = str(0.0)\\n tmism = str(float(int(my_line[8]) + int(my_line[13])) / misms)\\n cmism = str(float(int(my_line[9]) + int(my_line[14])) / misms)\\n else:\\n amism = str(float(int(my_line[6]) + int(my_line[11])) / misms)\\n gmism = str(float(int(my_line[7]) + int(my_line[12])) / misms)\\n tmism = str(0.0)\\n cmism = str(float(int(my_line[9]) + int(my_line[14])) / misms)\\n return amism, cmism, gmism, tmism\",\n \"def validation_tpr_at_95tpr(self):\\r\\n\\r\\n return self.validation_tpr_at_confidence(self.confidence_at_tpr(0.95))\",\n \"def get_gre_or_toefl(current_bucket_marks):\\r\\n\\r\\n computed_marks = current_bucket_marks.replace(\\\"\\\\n\\\", \\\"\\\").strip()\\r\\n try:\\r\\n int(computed_marks)\\r\\n return computed_marks\\r\\n except ValueError:\\r\\n return 0\",\n \"def Init(self):\\r\\n print(\\\"Initiating...\\\")\\r\\n if (self.Get_FullScale_Value() == self.FullScaleEnum[0]):\\r\\n self.gain = 0.00875\\r\\n elif (self.Get_FullScale_Value() == self.FullScaleEnum[1]):\\r\\n self.gain = 0.0175\\r\\n elif (self.Get_FullScale_Value() == self.FullScaleEnum[2]):\\r\\n self.gain = 0.07\\r\\n print(\\\"Gain set to:{0}\\\".format(self.gain))\",\n \"def mttr(self, down_time, failures=1, dec_point=3):\\n self.down_time = down_time\\n self.failures = failures\\n self.dec_point = dec_point\\n mt_tr = round(float(down_time / failures),dec_point)\\n return mt_tr\",\n \"def expected_result(self, other):\\r\\n return float(1) / (1 + math.pow(10, float(other.elo - self.elo) / DIVIDER))\",\n \"def calc_pr_rc_F1(GTD, block_occ):\\r\\n true_pos = ((GTD + block_occ)==2).sum()\\r\\n false_pos = sum([1 if BI_val==1 and GTD[i]==0 else 0 for i, BI_val in enumerate(block_occ.values)])\\r\\n precision = float(true_pos/(true_pos+false_pos))\\r\\n recall = float(true_pos/(GTD.sum()))\\r\\n if precision == 0:\\r\\n F1 = 0\\r\\n else:\\r\\n F1 = float(2 * (precision * recall) / (precision + recall))\\r\\n \\r\\n return precision, recall, F1\",\n \"def test_error_at_95tpr(self):\\r\\n\\r\\n return self.test_error_at_confidence(self.confidence_at_tpr(0.95))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6402152","0.63455784","0.6005763","0.6003944","0.5723235","0.5581667","0.5507382","0.5504862","0.5464299","0.546274","0.5449123","0.53767866","0.5366525","0.53509873","0.5350085","0.53294504","0.5323279","0.53189623","0.5305675","0.5283922","0.5271367","0.52711976","0.52618384","0.5257732","0.52442265","0.5207327","0.5206505","0.5184694","0.51842606","0.5177422","0.5177122","0.5175694","0.5171225","0.5160989","0.5158475","0.5158475","0.5152738","0.51476896","0.5146994","0.51384616","0.51373255","0.5129184","0.512519","0.51099527","0.5106394","0.5100407","0.50999","0.509356","0.50894576","0.506813","0.506793","0.50655425","0.5065229","0.5059086","0.50578725","0.5054466","0.50508744","0.50500804","0.50397295","0.5033908","0.5031231","0.5017864","0.5017483","0.50097597","0.50081205","0.4994208","0.49937594","0.49782014","0.4975815","0.49742863","0.49720076","0.4971949","0.49703568","0.49604854","0.49550325","0.4954864","0.49548292","0.49532124","0.4950589","0.49495676","0.49435976","0.4942507","0.49353814","0.493373","0.4932481","0.49239114","0.4922494","0.49213067","0.49205902","0.49204785","0.4918112","0.49180204","0.49158475","0.49155596","0.49134472","0.4906999","0.49062368","0.49056023","0.49017176","0.4901031"],"string":"[\n \"0.6402152\",\n \"0.63455784\",\n \"0.6005763\",\n \"0.6003944\",\n \"0.5723235\",\n \"0.5581667\",\n \"0.5507382\",\n \"0.5504862\",\n \"0.5464299\",\n \"0.546274\",\n \"0.5449123\",\n \"0.53767866\",\n \"0.5366525\",\n \"0.53509873\",\n \"0.5350085\",\n \"0.53294504\",\n \"0.5323279\",\n \"0.53189623\",\n \"0.5305675\",\n \"0.5283922\",\n \"0.5271367\",\n \"0.52711976\",\n \"0.52618384\",\n \"0.5257732\",\n \"0.52442265\",\n \"0.5207327\",\n \"0.5206505\",\n \"0.5184694\",\n \"0.51842606\",\n \"0.5177422\",\n \"0.5177122\",\n \"0.5175694\",\n \"0.5171225\",\n \"0.5160989\",\n \"0.5158475\",\n \"0.5158475\",\n \"0.5152738\",\n \"0.51476896\",\n \"0.5146994\",\n \"0.51384616\",\n \"0.51373255\",\n \"0.5129184\",\n \"0.512519\",\n \"0.51099527\",\n \"0.5106394\",\n \"0.5100407\",\n \"0.50999\",\n \"0.509356\",\n \"0.50894576\",\n \"0.506813\",\n \"0.506793\",\n \"0.50655425\",\n \"0.5065229\",\n \"0.5059086\",\n \"0.50578725\",\n \"0.5054466\",\n \"0.50508744\",\n \"0.50500804\",\n \"0.50397295\",\n \"0.5033908\",\n \"0.5031231\",\n \"0.5017864\",\n \"0.5017483\",\n \"0.50097597\",\n \"0.50081205\",\n \"0.4994208\",\n \"0.49937594\",\n \"0.49782014\",\n \"0.4975815\",\n \"0.49742863\",\n \"0.49720076\",\n \"0.4971949\",\n \"0.49703568\",\n \"0.49604854\",\n \"0.49550325\",\n \"0.4954864\",\n \"0.49548292\",\n \"0.49532124\",\n \"0.4950589\",\n \"0.49495676\",\n \"0.49435976\",\n \"0.4942507\",\n \"0.49353814\",\n \"0.493373\",\n \"0.4932481\",\n \"0.49239114\",\n \"0.4922494\",\n \"0.49213067\",\n \"0.49205902\",\n \"0.49204785\",\n \"0.4918112\",\n \"0.49180204\",\n \"0.49158475\",\n \"0.49155596\",\n \"0.49134472\",\n \"0.4906999\",\n \"0.49062368\",\n \"0.49056023\",\n \"0.49017176\",\n \"0.4901031\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.50264245"},"document_rank":{"kind":"string","value":"61"}}},{"rowIdx":12884,"cells":{"query":{"kind":"string","value":"calculate time course ddct divided by treated ddct"},"document":{"kind":"string","value":"def calculate_d3ct(self):\n data = deepcopy(self.ddct)\n data = data.set_index(['cell_line', 'replicate', 'Assay', 'time', 'treatment'])\n control = data.query('treatment == \"Control\"')#.reset_index(drop=True)\n tgfb = data.query('treatment == \"TGFb\"')#.reset_index(drop=True)\n control.index = control.index.droplevel(4)\n tgfb.index = tgfb.index.droplevel(4)\n return tgfb / control"},"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_ddct(self, baseline_time=0):\n\n if baseline_time == 0:\n baseline = self.baseline_data['dct'][0]\n\n elif baseline_time == 96:\n baseline = self.baseline_data['dct'][96]\n\n elif baseline_time == 'average':\n baseline = (self.baseline_data['dct'][0] + self.baseline_data['dct'][96]) / 2\n\n control =self.treatment_data.query('treatment == \"Control\"')['dct']\n tgf = self.treatment_data.query('treatment == \"TGFb\"')['dct']\n control.index = control.index.droplevel(1)\n tgf.index = tgf.index.droplevel(1)\n baseline.index = baseline.index.droplevel(1)\n\n time = control.columns\n\n tgf = pandas.concat([tgf[i]/baseline for i in tgf.columns], axis=1)\n control = pandas.concat([control[i]/baseline for i in control.columns], axis=1)\n\n control.columns = time\n tgf.columns = time\n\n control = pandas.DataFrame(control.stack())\n tgf = pandas.DataFrame(tgf.stack())\n control['treatment'] = 'Control'\n tgf['treatment'] = 'TGFb'\n df = pandas.concat([control, tgf]).reset_index()\n df.rename(columns={0: 'ddct'})\n return df","def timeFrac(t):\n\tlt = timeCalc(t)[1]\n\tunit = ['w', 'd', 'h', 'm', 's']\n\tmaxima = [0, 7.0, 24.0, 60.0, 60.0]\n\tfractions = [\"\", u\"\\xBC\", u\"\\u00BD\", u\"\\u00BE\", \"\"]\n\t#fractions = [\"0\", \"1/4\", \"1/2\", \"3/4\", \"0\"]\n\t# \t\t\t0\t\t1/4\t\t1/2\t\t3/4\t\n\tfor x, dp in enumerate(lt):\n\t\tif dp==0:\n\t\t\tcontinue\n\t\telse:\n\t\t\ta = dp\n\t\t\tb = 0\n\t\t\tfor y in range(x+1, len(lt)):\n\t\t\t\tb+= lt[y]/maxima[y]\n\t\t\tc = int(round(b, 1)//0.25)\n\t\t\tif b>0.8: \n\t\t\t\ta+=1\n\t\t\t\tb=0\n\t\t\t\tc=0\n\t\t\t#print \"a:{} b:{} c:{}, x:{}\".format(a, b, c, x)\n\t\t\t#d = u\"{}{}{}\".format(a, fractions[c]*(x>3), unit[x]) WHY THIS??\n\t\t\td = u\"{}{}{}\".format(a, fractions[c], unit[x])\n\t\t\treturn (d, (a, c, unit[x]))","def __div__(self, d):\r\n if isinstance(d, TimeInterface):\r\n return np.divide(np.array(self), np.array(d).astype(float))\r\n else:\r\n return np.divide(self, d)","def __div__(self, d):\r\n if isinstance(d, TimeInterface):\r\n return np.divide(np.array(self), np.array(d).astype(float))\r\n else:\r\n return np.divide(self, d)","def dechours(self, yr, mn, d, t):\n dt = datetime(int(yr), int(mn), int(d))\n if self.epochhours == 0:\n self.epochhours = self.datehours(dt)\n\n e = self.datehours(dt)\n result=-1.0\n if len(t) > 0:\n (h, m) = t.split(':')\n fh = float(h)\n fm = float(m)\n r = fh + fm/60.0\n result = e + round(r, 2)\n\n # print \"dechours: \" + str(result) + \" yr=\" + str(yr) + \" mn=\" + str(mn) + \" d=\" + str(d) + \" \" + t\n return result","def get_timediv(self):\n result = self.bus.ask('HOR:MAI:SCA?')\n return float(result.rstrip())","def dCdt(t,C,params_unknown, params_known, i):\r\n q_co2_interp,P0,C0,a,b,c,P = params_known\r\n d,M0 = params_unknown\r\n return (1-C)*q_co2_interp[i]/M0 -b/a/M0*(P[i]-P0)*(carbon_prime(C,P[i],P0)-C)-d*(C-C0)","def utility_time_score(self, g, w):\n occ = parse_time(g.occurred)\n iss = parse_time(w.submitted)\n diff = occ - iss\n return diff.total_seconds() / 86400","def dvdt(self, args: List[float]) -> float:\n v, n_kvhh, ca = args\n return ((-10.0*self.params.area \n * (self.kvhh.i(v, n=n_kvhh) \n + self.cav.i(v) \n + self.kca.i(v, ca=ca) \n + self.nap.i(v) \n + self.leak.i(v))) \n / (10.0*self.params.cm*self.params.area))","def part2(input):\n ps = PlanetSystem(input)\n c = ps.total_cycle_time()\n return c","def ddspmt(t):\n return (spmt(t) - _spm_dd_func(t)) / 0.01","def duration(self):\r\n return self.t2 - self.t1","def margin_timed(self):\n sp = self.sale_price_timed or zero\n if u.isempty(sp):\n return zero\n cp = self.cost_price or zero\n return u.decimal((um-(cp/sp))*cem, True)","def divs(cps):\n # Head of unit\n mask = cps['tc3_p'] > 0\n cps_valid = cps[mask]\n rand = np.random.uniform(size=len(cps_valid))\n new_vals = np.exp(10.5 + 1. * rand)\n new_vals = np.where(new_vals < 20000., 20000., new_vals)\n cps.loc[mask, 'dbep'] = new_vals\n # spouse of unit\n mask = cps['tc3_s'] > 0\n cps_valid = cps[mask]\n rand = np.random.uniform(size=len(cps_valid))\n new_vals = np.exp(10.5 + 1. * rand)\n new_vals = np.where(new_vals < 20000., 20000., new_vals)\n cps.loc[mask, 'dbes'] = new_vals","def elapsed_time(date_1, date_2, dtype):\n days_in_year = 365.\n return tf.cast(date_1.days_until(date_2), dtype=dtype) / (\n days_in_year)","def do_dt(r, t):\n return -o(r,t)/(2*t)","def dd2dms(dd):\r\n mnt,sec = divmod(dd*3600,60)\r\n deg,mnt = divmod(mnt,60)\r\n return deg,mnt,sec","def compute_duty_factor():\n [time,\n ankle_l_trajectory,\n ankle_r_trajectory,\n foot_l_contact,\n foot_r_contact,\n muscle_lh_activations,\n muscle_rh_activations,\n muscle_lh_forces,\n muscle_rh_forces,\n joint_lh_positions,\n joint_rh_positions] = load_data()\n \n print(np.sum(foot_l_contact)/len(foot_l_contact))\n print(np.sum(foot_r_contact)/len(foot_r_contact))\n\n return np.sum(foot_l_contact)/len(foot_l_contact)*0.5 + np.sum(foot_r_contact)/len(foot_r_contact)*0.5","def dmstodec(decd,decm,decs):\n\tif decd < 0:\n\t decm = -1*decm\n\t decs = -1*decs\n\n\tdecdegs = float(decd)+(float(decm)/60)+(float(decs)/3600.0)\n\n\tif abs(decdegs) > 90:\n\t raise ValueError\n\n\treturn decdegs","def dydt_div(y, t, alpha, mu):\n X, U, Y, V = y\n dXdt = U\n dYdt = V\n R2 = X**2 + Y**2\n # Gas flow diverges from point (X1, Y1) = (1/mu, 0)\n X1, Y1 = 1.0/mu, 0.0\n # Gas flow is radial from that point\n R1 = np.hypot(X - X1, Y - Y1)\n U1 = (X - X1)/R1\n V1 = (Y - Y1)/R1\n theta = np.arctan2(Y, X)\n dUdt = 0.5*(np.cos(theta)/R2 - alpha**2 * (U - U1))\n dVdt = 0.5*(np.sin(theta)/R2 - alpha**2 * (V - V1))\n return [dXdt, dUdt, dYdt, dVdt]","def GAME_TIME_ADVANCE(dt):","def calc_total_course_duration(timestamps):\n dt_conversion = [datetime.strptime(ts, '%M:%S') for ts in timestamps]\n baseline = datetime(1900, 1, 1, 0, 0, 0)\n for course_dt in dt_conversion:\n baseline = baseline + timedelta(minutes=course_dt.minute, seconds=course_dt.second) \n\n return baseline.strftime('%-H:%M:%S')","def dCadt(self, args: Dict) -> float:\n if self.channel_bool['cav']:\n i_cav: float = self.cav.i(args['v'])\n else:\n self.I_cav = 0\n\n if self.channel_bool['nmdar']:\n i_nmdar: float = self.nmdar.i(args['v'], s=args['s_nmdar'])\n else:\n i_nmdar: float = 0\n\n ca: float = args['ca']\n a_ca: float = self.params.a_ca\n area: float = self.params.area\n tau_ca: float = self.tau_ca\n dCadt: float = -a_ca * (10.0*area*i_cav) - a_ca*i_nmdar - ca/tau_ca\n return dCadt","def runtime_cal(start,end) :\n run_time = end - start\n mm = int(run_time/60)\n ss = round(run_time%60)\n return mm, ss","def pcr_delta_time_ms(pcr_t1, pcr_t2, offset = 0):\n return float(pcr_t2-pcr_t1)/90000.0 + offset","def f(t, v):\n dSdt = - (a * v[1] * v[0]) / N\n dUdt = (a * v[1] * v[0]) / N - c * v[1]\n dQdt = c * v[1] - b * v[2]\n dCdt = b * v[2]\n return [dSdt, dUdt, dQdt, dCdt]","def pc_work_time_avg(self):\n return _TestA_swig.cleanslate_sptr_pc_work_time_avg(self)","def t_sec(self):\n return self.t/self.parameters['time_conversion']","def calc_dtdc(tpbpcs, specs):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n Nbs = len(np.hstack(tpbpcs[0]))\n Ndraw = len(tpbpcs)\n\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\n\n for i in range(Ndraw):\n\n # Create array of times per bandpass\n dtpb[i,:] = np.hstack(tpbpcs[i])\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def compute_time_step():\n\n dt = Hydro.compute_time_step()\n\n return dt","def failed_per_hour(self):\r\n return (3600.*(self.circ_failed+self.strm_failed))/self.current_uptime()","def get_total_seconds(td):\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1e6) / 1e6","def get_tdelta(self, ch1: int, ch2: int) -> float:\n cmd = ':measure:deltatime? channel{0},channel{1}'.format(ch1, ch2)\n return float(self.query(cmd))","def _compute_duration_overtime(self):\n diff_float = 0\n for ts_line in self:\n if ts_line.x_start_date:\n st_datetime = fields.Datetime.from_string(\n ts_line.x_start_date)\n en_datetime = fields.Datetime.from_string(\n ts_line.x_end_date)\n diff = en_datetime - st_datetime\n if not ts_line.is_overtime:\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\n # del 1 hour for breaking lunch\n diff_float = round(\n diff.total_seconds() / 3600.0, 2)-1\n else:\n diff_float = round(diff.total_seconds() / 3600.0, 2)\n ts_line.x_is_per_diem = False\n ts_line.unit_amount = diff_float","def F_calctimescales(i, st, dm):\n mr = st.mn*dm.mxkg_v[i]/(st.mn+dm.mxkg_v[i]) # reduced mass, kg\n # containment time (orbits within Rs)\n t1 = c_yr2s( 2.7e-2 * m.pow(dm.mxkg_v[i]/st.mn,1.5) / (dm.sigx/1.e-55) ) # s \n # therm time\n tth1 = c_yr2s( 2.5e+5 * m.pow(dm.mxkg_v[i]/st.mn,2.) * m.pow(st.mn/mr,3.) / (dm.sigx/1.e-55) ) # s\n# tth2 = m.pow(dm.mxkg_v[i]/st.mn,2.) * pF / 6. / m.sqrt(2.) / st.Temp / st.nb / dm.sigx * m.pow(st.mn/mr,3.) \n tth2 = m.pow(dm.mxkg_v[i],2.)*st.mn*pF /4./m.sqrt(2.)/(st.nb*1.e+6)/dm.sigx_m/m.pow(st.mn,3.)/st.Eth\n tth = tth2\n print \"-- Time scales: t1=%.2e , tth=%.2e, tth1=%.2e, tth2=%.2e\" % (t1,tth,tth1,tth2)\n return t1, tth","def dCR_dt(pops, t=0):\n\n R = pops[0]\n C = pops[1]\n K = 10000000\n dRdt = r * R * (1-(R/K)) - a * R * C\n dCdt = -z * C + e * a * R * C\n\n return sc.array([dRdt, dCdt])","def lead_time_score(self, g, w):\n rep = parse_time(g.reported)\n iss = parse_time(w.submitted)\n diff = rep - iss\n return diff.total_seconds() / 86400","def dpTime():\n start_time = time.time()\n subjects = loadSubjects(SUBJECT_FILENAME)\n maxWork = 50\n answer = dpAdvisor(subjects, maxWork)\n end_time = time.time()\n printSubjects(answer)\n print 'Time taken: ', end_time - start_time\n return None","def dc_dt(self,C,t,K):\n \n # dc/dt built up by separately computing the positive and negative contributions.\n # In our example positive_dcdt = [0, k1[A], k2[B]] and negative_dcdt = [-k1[A],-k2[B],0]\n reaction_matrix = np.array(self.reaction_matrix,dtype=np.int)\n C = np.array(C)\n #K = np.array(K.valuesdict().values())\n\n # need to have the same number of rate parameters in K\n # as indicated in reaction_matrix!\n assert len(K) == np.sum(reaction_matrix)\n \n # need to be careful about dtypes:\n # reaction matrix dtype is int, rate matrix must be dtype float\n rate_matrix = reaction_matrix.copy()\n rate_matrix.dtype=np.float64\n rate_matrix[reaction_matrix==1] = K\n \n positive_dcdt = rate_matrix.T.dot(C)\n negative_dcdt = rate_matrix.T.sum(axis=0)*C\n \n return positive_dcdt - negative_dcdt","def averageTime(self):\n \n pass","def time_difference(time1: Time, time2: Time) -> float:\n dsec = time1.sec - time2.sec\n dnanosec = time1.nanosec - time2.nanosec\n dt = dsec + dnanosec/(10**9)\n return dt","def cps(self):\n return self.datacounts / self.exptime","def dCadt(self, args: List[float]) -> float:\n v, s_nmdar, ca = args\n a_ca: float = self.params.a_ca\n area: float = self.params.area\n tau_ca: float= self.tau_ca\n dCadt: float = (- a_ca * (10.0*area*self.cav.i(v))\n - a_ca * self.nmdar.i(v, s=s_nmdar)\n - ca / tau_ca)\n return dCadt","def duty_cycle(self):\n diff = np.diff(self.lc.time)\n t = np.median(diff)\n std = np.std(diff)\n mask = diff > (t + 3 * std)\n return (1 - np.sum(diff[mask]) / np.sum(diff))","def dY_dt(self, y, t=0):\n\t\t \n\t\t#variables\n\t\tpSgg = y[0] / float(sum(y))\n\t\tpSgh = y[3] / float(sum(y))\n\t\tpSh = y[3] / float(y[3] + y[4] + y[5])\n\t\t\n\t\t#exit flows\n\t\texit_Sg = y[0] * (1 / time_active) * t \n\t\texit_Pg = y[1] * (1 / time_active) * t\n\t\texit_PPg = y[2] * (1 / time_active) * t\n\t\texit_Sh = y[3] * (1 / time_active) * t\n\t\texit_Ph = y[4] * (1 / time_active) * t\n\t\texit_PPh = y[5] * (1 / time_active) * t\n\t\t#episodic flows\n\t\tSg_to_h = y[0] * (1 / tin_g) * t\n\t\tPg_to_h = y[1] * (1 / tin_g) * t\n\t\tPPg_to_h = y[2] * (1 / tin_g) * t\n\t\tSh_to_g = y[3] * (1 / tin_h) * t\n\t\tPh_to_g = y[4] * (1 / tin_h) * t\n\t\tPPh_to_g = y[5] * (1 / tin_h) * t\n\t\t#entry flows\n\t\tinto_g = new_g * t\n\t\tinto_h = new_h * t\n\t\t#infection flows\n\t\tnewinf_gg = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgg * t\n\t\tnewinf_gh = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgh * t\n\t\tnewinf_h = (y[4] * B1 + y[5] * B2) * Ch * pSh * t\n\t\t#stage progression flows\n\t\tPg_to_PPg = y[1] * D1 * t\n\t\tPPg_to_d = y[2] * D2 * t\n\t\tPh_to_PPh = y[4] * D1 * t\n\t\tPPh_to_d = y[5] * D2 * t\n\t\t\t\n\t\tstate = [- exit_Sg - newinf_gg - Sg_to_h + into_g + Sh_to_g,\n\t\t\t\t - exit_Pg - Pg_to_PPg - Pg_to_h + newinf_gg + Ph_to_g,\n\t\t\t\t - exit_PPg - PPg_to_d - PPg_to_h + Pg_to_PPg + PPh_to_g,\n\t\t\t\t - exit_Sh - newinf_gh - newinf_h - Sh_to_g + into_h + Sg_to_h,\n\t\t\t\t - exit_Ph - Ph_to_PPh - Ph_to_g + newinf_gh + newinf_h + Pg_to_h,\n\t\t\t\t - exit_PPh - PPh_to_d - PPh_to_g + Ph_to_PPh + PPg_to_h]\n\t\n\t\treturn state","def pc_work_time_avg(self) -> \"float\":\n return _beamforming_swig.doaesprit_sptr_pc_work_time_avg(self)","def transit_duration(rstar, logg, per, ecc):\n # Replace large ecc values with 0.99\n ecc = np.where(ecc > 0.99, 0.99, ecc)\n # Convert logg and rstar into stellar mass\n mstar = mstar_from_stellarprops(rstar, logg)\n # Semi-major axis in AU\n semia = mstar**(1.0/3.0) * (per/365.25)**(2.0/3.0)\n # transit duration e=0 including pi/4 effect of cos(inc) dist\n r_sun = 6.9598e10 # cm\n au2cm = 1.49598e13 # 1 AU = 1.49598e13 cm\n durat = (per*24.0) / 4.0 * (rstar*r_sun) / (semia*au2cm)\n #transit duration e > 0\n durat = durat * np.sqrt(1.0-ecc**2);\n\n return durat","def timefactor(self, period):\n\t\tdays = period.size() * self.daysinunit(period.unit)\n\t\treturn float(days)/self.daysinbase","def sectoFracYear(stime):\n\n ltime = convertCtimeToYdate(stime)\n atemp = re.split(':', ltime)\n year= int(atemp[0])\n ydate = int(atemp[1])\n hours = int(atemp[2])\n minutes = int(atemp[3])\n seconds = int(atemp[4])\n \n chk = 4.0 * int(0.25 * year)\n if chk == year:\n base = 366\n else:\n base = 365\n \n day = ydate + hours / 24.0 + minutes / 1440.0 + seconds / 86400.0\n \n return year + day / base","def ctime(self): # real signature unknown; restored from __doc__\r\n pass","def _calculate_runtime(self):\n lines = self.file_dic['output'].splitlines()\n start_time = datetime.strptime(lines[0].strip(), self.timestring_format)\n fin_time = datetime.strptime(lines[-1].strip(), self.timestring_format)\n dif = fin_time - start_time\n self.date = fin_time.strftime('%d %b %Y')\n self.runtime = dif.total_seconds()","def diff_op(self, args: List[float], time: float) -> List[float]:\n v, nK, ca = args\n ca_args: List[float] = [v, ca]\n dvdt: float = self.dvdt(args=args)\n dnKdt: float = self.kvhh.dndt(v=v, n=nK)\n dCadt: float = self.dCadt(args=ca_args)\n return [dvdt, dnKdt, dCadt]","def total_seconds(td):\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6","def _normalizeDeltaTime(self, dt : float) -> float:\n return dt / self.tau","def compute_dsc(self, original, shrinked):\n for i in range(len(original)):\n x, y = original[i]\n orig = y-x\n\n a, b = shrinked[i]\n new = b-a\n\n dsc = float(new/orig)\n\n return dsc","def calc_time(self, distance):\r\n if distance < 400:\r\n return 2*math.sqrt(distance / 1406.25)\r\n else:\r\n distance -= 400\r\n return distance / 750 + 16 / 15","def test_day_percentage_timedelta(self):\n delta = timedelta(seconds=987654, microseconds=321)\n day_percentage = utils.day_percentage(delta)\n self.assertEqual(day_percentage, 11.431180559270834)","def arithmetic_ret(self) -> float:\n return float(np.log(self.tsdf).diff().mean() * self.periods_in_a_year)","def normalize_times(time,dtstart,dtend):\n time=np.datetime64(time)\n dtstart=np.datetime64(dtstart)\n dtend=np.datetime64(dtend)\n time_range = (dtend - dtstart).astype('float64')\n seconds_from_t0 = (time - dtstart).astype('float64')\n return seconds_from_t0 / time_range","def sct_numericdate(cls, d):\n return (d-cls.SCT_EPOCH).total_seconds() / 60","def dCadt(self, args: List[float]) -> float:\n v, ca = args\n a_Ca: float = self.params.a_ca\n area: float = self.params.area\n tau_Ca: float = self.tau_ca\n dCadt: float = -a_Ca * (10.0*area*self.cav.i(v)) - ca/tau_Ca\n return dCadt","def seconds_elapsed(date1, date2):\n return (date1 - date2).total_seconds()","def calc_dtdc_star(tpbpc0, spec):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n # Create array of times per bandpass\n dtpb = np.hstack(tpbpc0)\n\n Nbs = len(dtpb)\n dcomp = np.zeros(Nbs) # completeness\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def calc_a(dert__):\n return dert__[[2, 3]] / dert__[1] # np.array([dy, dx]) / g","def calc_total_course_duration(timestamps):\n answer = timedelta()\n \n for times in timestamps:\n m, s = times.split(':')\n answer += timedelta(minutes=int(m), seconds=int(s))\n \n return datetime.strptime(str(answer), '%H:%M:%S').strftime('%H:%M:%S')\n pass","def time_division(annuli):\n \n time_div=np.empty(len(annuli),dtype=int)\n for annulus in range(len(annuli)):\n r = annuli[annulus]\n time_div[annulus]=int(viscous_timescale(r) * sample_ratio)\n return time_div","def get_elapsed_time(start, end):\n return \"%s days, %s hours, %s minutes, %s seconds\" % dhms_from_seconds(date_diff_in_seconds(start, end))","def test_cdf_vs_dt_cy():\n burstsph, _ = load_burstsph()\n ns = 1.0\n nm = 1.0\n δt = 1e-2 * ns\n R0 = 6 * nm\n R_mean = 6.5 * nm\n R_sigma = 1 * nm\n τ_relax = 0.2 * ns\n τ_D = 4. * ns\n k_D = 1. / τ_D\n D_fract = np.atleast_1d(1.)\n ts = burstsph.timestamp.values[:100000]\n rg = RandomGenerator(Xoroshiro128(1))\n R_ph, T_ph = depi_cy.sim_DA_from_timestamps2_p_cy(\n ts, δt, k_D, R0, R_mean, R_sigma, τ_relax, rg, ndt=0, alpha=np.inf)\n rg = RandomGenerator(Xoroshiro128(1))\n R_php, T_php = depi_cy.sim_DA_from_timestamps2_p2_cy(\n ts, δt, np.atleast_1d(k_D), D_fract, R0, R_mean, R_sigma, τ_relax, rg=rg,\n ndt=0, alpha=np.inf)\n assert not all([not np.allclose(R_ph, R_php),\n not np.allclose(T_ph, T_php)])","def mdct(x, odd=True):\n return numpy.real(cmdct(x, odd=odd)) * numpy.sqrt(2)","def total_time(self):\n obs_times = self.clean_obs_times()\n return _np.sum(obs_times[:, 1] - obs_times[:, 0])","def trip_duration_stats(df):\n\n print('\\nCalculating Trip Duration...\\n')\n start_time = time.time()\n\n # TO DO: display total travel time\n\n total_travel_time_in_sec = df['Trip Duration'].sum()\n total_travel_time_in_years = total_travel_time_in_sec // (60 * 60 * 24 *365)\n\n modulus1_in_sec = total_travel_time_in_sec - total_travel_time_in_years*(60 * 60 * 24 *365)\n #print(\"modulus1_in_sec:\", modulus1_in_sec)\n total_travel_time_in_months = modulus1_in_sec // (60 * 60 * 24 *31)\n\n modulus2_in_sec = modulus1_in_sec - total_travel_time_in_months*(60 * 60 * 24 *31)\n #print(\"modulus2_in_sec:\", modulus2_in_sec)\n total_travel_time_in_weeks = modulus2_in_sec // (60 * 60 * 24 *7)\n\n modulus3_in_sec = modulus2_in_sec - total_travel_time_in_weeks*(60 * 60 * 24 *7)\n #print(\"modulus3_in_sec:\", modulus3_in_sec)\n total_travel_time_in_days = modulus3_in_sec // (60 * 60 * 24)\n\n modulus4_in_sec = modulus3_in_sec - total_travel_time_in_days*(60 * 60 * 24)\n #print(\"modulus4_in_sec:\", modulus4_in_sec)\n total_travel_time_in_hours = modulus4_in_sec // (60 * 60)\n\n modulus5_in_sec = modulus4_in_sec - total_travel_time_in_hours*(60 * 60)\n #print(\"modulus5_in_sec:\", modulus5_in_sec)\n total_travel_time_in_minutes = modulus5_in_sec // 60\n\n modulus6_in_sec = modulus5_in_sec - total_travel_time_in_minutes*60\n #print(\"modulus6_in_sec:\", modulus6_in_sec)\n total_travel_time_in_seconds_modulus = modulus6_in_sec\n\n print(\"total travel time of all Users combined:\\n YEARS: {} \\n MONTHS: {} \\n WEEKS: {} \\n DAYS: {} \\n HOURS: {} \\n MINUTES: {} \\n SECONDS: {} \\n\".format(total_travel_time_in_years, total_travel_time_in_months, total_travel_time_in_weeks, total_travel_time_in_days, total_travel_time_in_hours, total_travel_time_in_minutes, total_travel_time_in_seconds_modulus))\n\n # TO DO: display mean travel time\n\n mean_travel_time_in_sec = df['Trip Duration'].mean()\n mean_travel_time_in_minutes = mean_travel_time_in_sec // 60\n modulus_in_sec = mean_travel_time_in_sec - mean_travel_time_in_minutes*60\n mean_travel_time_in_seconds_modulus = modulus_in_sec\n\n print(\"mean travel time:\\n MINUTES: {} \\n SECONDS: {} \\n\".format(int(mean_travel_time_in_minutes), mean_travel_time_in_seconds_modulus))\n\n#trip_duration_stats(pd.read_csv('{}.csv'.format(city)))\n\n print(\"\\nThis took %s seconds.\" % (time.time() - start_time))\n print('-'*40)","def discharge_date_time(subject_id, conn):\n cur = conn.cursor()\n sql = \"\"\"SELECT ED_DEPARTURE_TIME, EDDisposition FROM DEMOGRAPHICS\n WHERE STUDYID = {}\"\"\".format(subject_id)\n cur.execute(sql)\n data = cur.fetchall()\n if data[0][0]: # subjects who were discharged from the ED\n date, time = data[0][0].split(\" \")\n dispo = data[0][1]\n return date, time, 'discharge', dispo\n else: # Subjects who were admitted\n sql = \"\"\"SELECT HOSP_ADMSN_TIME, EDDisposition FROM DEMOGRAPHICS\n WHERE STUDYID = {}\"\"\".format(subject_id)\n cur.execute(sql)\n data = cur.fetchall()\n if data[0][0]:\n date, time = data[0][0].split(\" \")\n dispo = data[0][1]\n return date, time, 'discharge', dispo","def t_conv_func(t_end,t_start,input_type='datetime',output_units='hours'):\n if input_type == \"datetime\":\n diff = (t_end-t_start).total_seconds ()\n elif input_type == \"seconds\":\n diff = t_end-t_start\n else:\n raise NotImplementedError\n\n if output_units == 'seconds':\n return diff\n elif output_units == 'minutes':\n return diff/60.0\n elif output_units == 'hours':\n return diff/3600.0\n else:\n raise NotImplementedError","def pc_work_time_avg(self):\n return _spacegrant_swig.hdlc_deframer_sptr_pc_work_time_avg(self)","def d_dt(self, r, t):\n return self.d_do(r,t) * do_dt(r,t)","def discretize(self,dt):\n res = self.discretize_state(dt)\n n = len(res.milestones[0])//2\n return Trajectory(res.times,[m[:n] for m in res.milestones])","def get_dt_per_index(self):\n dt = self.data[1,-1] - self.data[0,-1]\n return dt","def dd2sec(dd):\n minute, second = divmod(abs(dd) * 3600, 60)\n degree, minute = divmod(minute, 60)\n sec = (degree * 3600) + (minute * 60) + second\n return sec if dd >= 0 else -sec","def get_duration(self):\n return float(self.time.iloc[-1] - self.time.iloc[0])","def calculer_energie_cinetique_tnt(energie_cinetique):\n return energie_cinetique / 4184","def __call__(self):\n \n if self.funciona:\n t = self.timeFunc() - self.t0 - self.retraso\n elif self.t0!=None:\n t = self.parada - self.t0 - self.retraso\n else:\n t = None\n return t","def period(self) -> int:","def _steps_to_seconds(steps, qpm):\n return steps * 60.0 / qpm / get_steps_per_quarter()","def advantage(cpu_dt, gpu_dt):\n assert gpu_dt >= 0 and cpu_dt >= 0\n if gpu_dt == 0 and cpu_dt == 0:\n return numpy.nan\n elif gpu_dt == 0:\n return numpy.inf\n else:\n return cpu_dt / gpu_dt","def advantage(cpu_dt, gpu_dt):\r\n assert gpu_dt >= 0 and cpu_dt >= 0\r\n if gpu_dt == 0 and cpu_dt == 0:\r\n return numpy.nan\r\n elif gpu_dt == 0:\r\n return numpy.inf\r\n else:\r\n return cpu_dt / gpu_dt","def REAL_TIME_ADVANCE(dt):","def _STEPS2TIME(step):\n return step/1000.","def get_dtc(self):\n r = self.sensor(1)\n num = r[0]\n # get all DTC, 3 per mesg response\n self.send_command(GET_DTC_COMMAND)\n #for i in range(0, ceil(num/3.0)):\n res = self.get_result()\n print res\n return res\n # fixme: finish","def dspmt(t):\n t = np.asarray(t)\n return spmt(t) - spmt(t - 1)","def test_curriculum_progress(self):\n student_id = '0104926787'\n career_id = 44\n curriculum_id = 1\n career_plan = 4\n expected_result = self._get_curriculum_progress()\n actual_result = self.ucuenca.curriculum_progress(\n student_id, career_id, curriculum_id, career_plan\n )\n self.assertEqual(actual_result, expected_result)","def pc_work_time_total(self):\n return _TestA_swig.cleanslate_sptr_pc_work_time_total(self)","def ddm(self):\n if self.positive:\n return DDMAngle(self.degree, self.minute + (self.second/60))\n else:\n return -DDMAngle(self.degree, self.minute + (self.second/60))","def dvdt(self, args: List[float]) -> float:\n v, h_nav, n_kvhh, h_kva, m_kvsi, s_ampar, _, s_nmdar, s_gabar, ca = args\n return ((-10.0*self.params.area \n * (self.leak.i(v)\n + self.nav.i(v, h=h_nav) \n + self.kvhh.i(v, n=n_kvhh)\n + self.kva.i(v, h=h_kva)\n + self.kvsi.i(v, m=m_kvsi)\n + self.cav.i(v)\n + self.kca.i(v, ca=ca)\n + self.nap.i(v)\n + self.kir.i(v))\n - (self.ampar.i(v, s=s_ampar)\n + self.nmdar.i(v, s=s_nmdar)\n + self.gabar.i(v, s=s_gabar))) \n / (10.0*self.params.cm*self.params.area))","def pc_work_time_avg(self) -> \"float\":\n return _beamforming_swig.phasedarray_sptr_pc_work_time_avg(self)","def tt_ut1(self):\n # return the delta time for the input date converted to days\n return interpolate_delta_time(_delta_file, self.tide)","def trip_duration_stats(df, city):\r\n\r\n print(\"\\n\" * 2 + '*' * 20)\r\n print('Calculating Trip Duration...\\n')\r\n start_time = time.time()\r\n \r\n # TO DO: display total travel time\r\n try:\r\n df['Time Delta'] = df['End Time'] - df['Start Time']\r\n total_time_delta = df['Time Delta'].sum()\r\n print('The total travel time :', total_time_delta)\r\n except Exeption as e:\r\n print('An exception has been occurred while displaying total travel time: {}'.format(e))\r\n \r\n # TO DO: display mean travel time\r\n try:\r\n total_mean = df['Time Delta'].mean()\r\n print('The mean travel time :', total_mean)\r\n except Exception as e:\r\n print('An exception has been occurred while displaying mean travel time: {}'.format(e))\r\n \r\n print(\"\\nThis took %s seconds.\" % (time.time() - start_time))\r\n print('*' * 20)","def get_frac_secs(self):\n return _uhd_swig.time_spec_t_get_frac_secs(self)","def suspected_per_hour(self):\r\n return (3600.*(self.circ_suspected+self.strm_suspected\r\n +self.circ_failed+self.strm_failed))/self.current_uptime()","def _compute_duration(self):\n diff_float = 0\n for ts_line in self:\n if ts_line.x_start_date:\n st_datetime = fields.Datetime.from_string(\n ts_line.x_start_date)\n # autocomplete date from start date\n st_date_tz = fields.Datetime.context_timestamp(\n self, st_datetime).date()\n ts_line.date = st_date_tz\n\n # autocomplete name from start date\n st_datetime_tz = fields.Datetime.context_timestamp(\n self, st_datetime)\n string_st_dt_tz = fields.Datetime.to_string(st_datetime_tz)\n ts_line.name = ts_line.user_id.name + '/' + string_st_dt_tz\n\n en_datetime = fields.Datetime.from_string(\n ts_line.x_end_date)\n diff = en_datetime - st_datetime\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\n # del 1 hour for breaking lunch\n diff_float = round(diff.total_seconds() / 3600.0, 2)-1\n else:\n diff_float = round(diff.total_seconds() / 3600.0, 2)\n ts_line.unit_amount = diff_float","def getDuration(self):\n #return np.sum(self.subintinfo['TSUBINT']) #This is constant.\n return np.sum(self.getSubintinfo('TSUBINT')) #This is constant."],"string":"[\n \"def calculate_ddct(self, baseline_time=0):\\n\\n if baseline_time == 0:\\n baseline = self.baseline_data['dct'][0]\\n\\n elif baseline_time == 96:\\n baseline = self.baseline_data['dct'][96]\\n\\n elif baseline_time == 'average':\\n baseline = (self.baseline_data['dct'][0] + self.baseline_data['dct'][96]) / 2\\n\\n control =self.treatment_data.query('treatment == \\\"Control\\\"')['dct']\\n tgf = self.treatment_data.query('treatment == \\\"TGFb\\\"')['dct']\\n control.index = control.index.droplevel(1)\\n tgf.index = tgf.index.droplevel(1)\\n baseline.index = baseline.index.droplevel(1)\\n\\n time = control.columns\\n\\n tgf = pandas.concat([tgf[i]/baseline for i in tgf.columns], axis=1)\\n control = pandas.concat([control[i]/baseline for i in control.columns], axis=1)\\n\\n control.columns = time\\n tgf.columns = time\\n\\n control = pandas.DataFrame(control.stack())\\n tgf = pandas.DataFrame(tgf.stack())\\n control['treatment'] = 'Control'\\n tgf['treatment'] = 'TGFb'\\n df = pandas.concat([control, tgf]).reset_index()\\n df.rename(columns={0: 'ddct'})\\n return df\",\n \"def timeFrac(t):\\n\\tlt = timeCalc(t)[1]\\n\\tunit = ['w', 'd', 'h', 'm', 's']\\n\\tmaxima = [0, 7.0, 24.0, 60.0, 60.0]\\n\\tfractions = [\\\"\\\", u\\\"\\\\xBC\\\", u\\\"\\\\u00BD\\\", u\\\"\\\\u00BE\\\", \\\"\\\"]\\n\\t#fractions = [\\\"0\\\", \\\"1/4\\\", \\\"1/2\\\", \\\"3/4\\\", \\\"0\\\"]\\n\\t# \\t\\t\\t0\\t\\t1/4\\t\\t1/2\\t\\t3/4\\t\\n\\tfor x, dp in enumerate(lt):\\n\\t\\tif dp==0:\\n\\t\\t\\tcontinue\\n\\t\\telse:\\n\\t\\t\\ta = dp\\n\\t\\t\\tb = 0\\n\\t\\t\\tfor y in range(x+1, len(lt)):\\n\\t\\t\\t\\tb+= lt[y]/maxima[y]\\n\\t\\t\\tc = int(round(b, 1)//0.25)\\n\\t\\t\\tif b>0.8: \\n\\t\\t\\t\\ta+=1\\n\\t\\t\\t\\tb=0\\n\\t\\t\\t\\tc=0\\n\\t\\t\\t#print \\\"a:{} b:{} c:{}, x:{}\\\".format(a, b, c, x)\\n\\t\\t\\t#d = u\\\"{}{}{}\\\".format(a, fractions[c]*(x>3), unit[x]) WHY THIS??\\n\\t\\t\\td = u\\\"{}{}{}\\\".format(a, fractions[c], unit[x])\\n\\t\\t\\treturn (d, (a, c, unit[x]))\",\n \"def __div__(self, d):\\r\\n if isinstance(d, TimeInterface):\\r\\n return np.divide(np.array(self), np.array(d).astype(float))\\r\\n else:\\r\\n return np.divide(self, d)\",\n \"def __div__(self, d):\\r\\n if isinstance(d, TimeInterface):\\r\\n return np.divide(np.array(self), np.array(d).astype(float))\\r\\n else:\\r\\n return np.divide(self, d)\",\n \"def dechours(self, yr, mn, d, t):\\n dt = datetime(int(yr), int(mn), int(d))\\n if self.epochhours == 0:\\n self.epochhours = self.datehours(dt)\\n\\n e = self.datehours(dt)\\n result=-1.0\\n if len(t) > 0:\\n (h, m) = t.split(':')\\n fh = float(h)\\n fm = float(m)\\n r = fh + fm/60.0\\n result = e + round(r, 2)\\n\\n # print \\\"dechours: \\\" + str(result) + \\\" yr=\\\" + str(yr) + \\\" mn=\\\" + str(mn) + \\\" d=\\\" + str(d) + \\\" \\\" + t\\n return result\",\n \"def get_timediv(self):\\n result = self.bus.ask('HOR:MAI:SCA?')\\n return float(result.rstrip())\",\n \"def dCdt(t,C,params_unknown, params_known, i):\\r\\n q_co2_interp,P0,C0,a,b,c,P = params_known\\r\\n d,M0 = params_unknown\\r\\n return (1-C)*q_co2_interp[i]/M0 -b/a/M0*(P[i]-P0)*(carbon_prime(C,P[i],P0)-C)-d*(C-C0)\",\n \"def utility_time_score(self, g, w):\\n occ = parse_time(g.occurred)\\n iss = parse_time(w.submitted)\\n diff = occ - iss\\n return diff.total_seconds() / 86400\",\n \"def dvdt(self, args: List[float]) -> float:\\n v, n_kvhh, ca = args\\n return ((-10.0*self.params.area \\n * (self.kvhh.i(v, n=n_kvhh) \\n + self.cav.i(v) \\n + self.kca.i(v, ca=ca) \\n + self.nap.i(v) \\n + self.leak.i(v))) \\n / (10.0*self.params.cm*self.params.area))\",\n \"def part2(input):\\n ps = PlanetSystem(input)\\n c = ps.total_cycle_time()\\n return c\",\n \"def ddspmt(t):\\n return (spmt(t) - _spm_dd_func(t)) / 0.01\",\n \"def duration(self):\\r\\n return self.t2 - self.t1\",\n \"def margin_timed(self):\\n sp = self.sale_price_timed or zero\\n if u.isempty(sp):\\n return zero\\n cp = self.cost_price or zero\\n return u.decimal((um-(cp/sp))*cem, True)\",\n \"def divs(cps):\\n # Head of unit\\n mask = cps['tc3_p'] > 0\\n cps_valid = cps[mask]\\n rand = np.random.uniform(size=len(cps_valid))\\n new_vals = np.exp(10.5 + 1. * rand)\\n new_vals = np.where(new_vals < 20000., 20000., new_vals)\\n cps.loc[mask, 'dbep'] = new_vals\\n # spouse of unit\\n mask = cps['tc3_s'] > 0\\n cps_valid = cps[mask]\\n rand = np.random.uniform(size=len(cps_valid))\\n new_vals = np.exp(10.5 + 1. * rand)\\n new_vals = np.where(new_vals < 20000., 20000., new_vals)\\n cps.loc[mask, 'dbes'] = new_vals\",\n \"def elapsed_time(date_1, date_2, dtype):\\n days_in_year = 365.\\n return tf.cast(date_1.days_until(date_2), dtype=dtype) / (\\n days_in_year)\",\n \"def do_dt(r, t):\\n return -o(r,t)/(2*t)\",\n \"def dd2dms(dd):\\r\\n mnt,sec = divmod(dd*3600,60)\\r\\n deg,mnt = divmod(mnt,60)\\r\\n return deg,mnt,sec\",\n \"def compute_duty_factor():\\n [time,\\n ankle_l_trajectory,\\n ankle_r_trajectory,\\n foot_l_contact,\\n foot_r_contact,\\n muscle_lh_activations,\\n muscle_rh_activations,\\n muscle_lh_forces,\\n muscle_rh_forces,\\n joint_lh_positions,\\n joint_rh_positions] = load_data()\\n \\n print(np.sum(foot_l_contact)/len(foot_l_contact))\\n print(np.sum(foot_r_contact)/len(foot_r_contact))\\n\\n return np.sum(foot_l_contact)/len(foot_l_contact)*0.5 + np.sum(foot_r_contact)/len(foot_r_contact)*0.5\",\n \"def dmstodec(decd,decm,decs):\\n\\tif decd < 0:\\n\\t decm = -1*decm\\n\\t decs = -1*decs\\n\\n\\tdecdegs = float(decd)+(float(decm)/60)+(float(decs)/3600.0)\\n\\n\\tif abs(decdegs) > 90:\\n\\t raise ValueError\\n\\n\\treturn decdegs\",\n \"def dydt_div(y, t, alpha, mu):\\n X, U, Y, V = y\\n dXdt = U\\n dYdt = V\\n R2 = X**2 + Y**2\\n # Gas flow diverges from point (X1, Y1) = (1/mu, 0)\\n X1, Y1 = 1.0/mu, 0.0\\n # Gas flow is radial from that point\\n R1 = np.hypot(X - X1, Y - Y1)\\n U1 = (X - X1)/R1\\n V1 = (Y - Y1)/R1\\n theta = np.arctan2(Y, X)\\n dUdt = 0.5*(np.cos(theta)/R2 - alpha**2 * (U - U1))\\n dVdt = 0.5*(np.sin(theta)/R2 - alpha**2 * (V - V1))\\n return [dXdt, dUdt, dYdt, dVdt]\",\n \"def GAME_TIME_ADVANCE(dt):\",\n \"def calc_total_course_duration(timestamps):\\n dt_conversion = [datetime.strptime(ts, '%M:%S') for ts in timestamps]\\n baseline = datetime(1900, 1, 1, 0, 0, 0)\\n for course_dt in dt_conversion:\\n baseline = baseline + timedelta(minutes=course_dt.minute, seconds=course_dt.second) \\n\\n return baseline.strftime('%-H:%M:%S')\",\n \"def dCadt(self, args: Dict) -> float:\\n if self.channel_bool['cav']:\\n i_cav: float = self.cav.i(args['v'])\\n else:\\n self.I_cav = 0\\n\\n if self.channel_bool['nmdar']:\\n i_nmdar: float = self.nmdar.i(args['v'], s=args['s_nmdar'])\\n else:\\n i_nmdar: float = 0\\n\\n ca: float = args['ca']\\n a_ca: float = self.params.a_ca\\n area: float = self.params.area\\n tau_ca: float = self.tau_ca\\n dCadt: float = -a_ca * (10.0*area*i_cav) - a_ca*i_nmdar - ca/tau_ca\\n return dCadt\",\n \"def runtime_cal(start,end) :\\n run_time = end - start\\n mm = int(run_time/60)\\n ss = round(run_time%60)\\n return mm, ss\",\n \"def pcr_delta_time_ms(pcr_t1, pcr_t2, offset = 0):\\n return float(pcr_t2-pcr_t1)/90000.0 + offset\",\n \"def f(t, v):\\n dSdt = - (a * v[1] * v[0]) / N\\n dUdt = (a * v[1] * v[0]) / N - c * v[1]\\n dQdt = c * v[1] - b * v[2]\\n dCdt = b * v[2]\\n return [dSdt, dUdt, dQdt, dCdt]\",\n \"def pc_work_time_avg(self):\\n return _TestA_swig.cleanslate_sptr_pc_work_time_avg(self)\",\n \"def t_sec(self):\\n return self.t/self.parameters['time_conversion']\",\n \"def calc_dtdc(tpbpcs, specs):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n Nbs = len(np.hstack(tpbpcs[0]))\\n Ndraw = len(tpbpcs)\\n\\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\\n\\n for i in range(Ndraw):\\n\\n # Create array of times per bandpass\\n dtpb[i,:] = np.hstack(tpbpcs[i])\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def compute_time_step():\\n\\n dt = Hydro.compute_time_step()\\n\\n return dt\",\n \"def failed_per_hour(self):\\r\\n return (3600.*(self.circ_failed+self.strm_failed))/self.current_uptime()\",\n \"def get_total_seconds(td):\\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1e6) / 1e6\",\n \"def get_tdelta(self, ch1: int, ch2: int) -> float:\\n cmd = ':measure:deltatime? channel{0},channel{1}'.format(ch1, ch2)\\n return float(self.query(cmd))\",\n \"def _compute_duration_overtime(self):\\n diff_float = 0\\n for ts_line in self:\\n if ts_line.x_start_date:\\n st_datetime = fields.Datetime.from_string(\\n ts_line.x_start_date)\\n en_datetime = fields.Datetime.from_string(\\n ts_line.x_end_date)\\n diff = en_datetime - st_datetime\\n if not ts_line.is_overtime:\\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\\n # del 1 hour for breaking lunch\\n diff_float = round(\\n diff.total_seconds() / 3600.0, 2)-1\\n else:\\n diff_float = round(diff.total_seconds() / 3600.0, 2)\\n ts_line.x_is_per_diem = False\\n ts_line.unit_amount = diff_float\",\n \"def F_calctimescales(i, st, dm):\\n mr = st.mn*dm.mxkg_v[i]/(st.mn+dm.mxkg_v[i]) # reduced mass, kg\\n # containment time (orbits within Rs)\\n t1 = c_yr2s( 2.7e-2 * m.pow(dm.mxkg_v[i]/st.mn,1.5) / (dm.sigx/1.e-55) ) # s \\n # therm time\\n tth1 = c_yr2s( 2.5e+5 * m.pow(dm.mxkg_v[i]/st.mn,2.) * m.pow(st.mn/mr,3.) / (dm.sigx/1.e-55) ) # s\\n# tth2 = m.pow(dm.mxkg_v[i]/st.mn,2.) * pF / 6. / m.sqrt(2.) / st.Temp / st.nb / dm.sigx * m.pow(st.mn/mr,3.) \\n tth2 = m.pow(dm.mxkg_v[i],2.)*st.mn*pF /4./m.sqrt(2.)/(st.nb*1.e+6)/dm.sigx_m/m.pow(st.mn,3.)/st.Eth\\n tth = tth2\\n print \\\"-- Time scales: t1=%.2e , tth=%.2e, tth1=%.2e, tth2=%.2e\\\" % (t1,tth,tth1,tth2)\\n return t1, tth\",\n \"def dCR_dt(pops, t=0):\\n\\n R = pops[0]\\n C = pops[1]\\n K = 10000000\\n dRdt = r * R * (1-(R/K)) - a * R * C\\n dCdt = -z * C + e * a * R * C\\n\\n return sc.array([dRdt, dCdt])\",\n \"def lead_time_score(self, g, w):\\n rep = parse_time(g.reported)\\n iss = parse_time(w.submitted)\\n diff = rep - iss\\n return diff.total_seconds() / 86400\",\n \"def dpTime():\\n start_time = time.time()\\n subjects = loadSubjects(SUBJECT_FILENAME)\\n maxWork = 50\\n answer = dpAdvisor(subjects, maxWork)\\n end_time = time.time()\\n printSubjects(answer)\\n print 'Time taken: ', end_time - start_time\\n return None\",\n \"def dc_dt(self,C,t,K):\\n \\n # dc/dt built up by separately computing the positive and negative contributions.\\n # In our example positive_dcdt = [0, k1[A], k2[B]] and negative_dcdt = [-k1[A],-k2[B],0]\\n reaction_matrix = np.array(self.reaction_matrix,dtype=np.int)\\n C = np.array(C)\\n #K = np.array(K.valuesdict().values())\\n\\n # need to have the same number of rate parameters in K\\n # as indicated in reaction_matrix!\\n assert len(K) == np.sum(reaction_matrix)\\n \\n # need to be careful about dtypes:\\n # reaction matrix dtype is int, rate matrix must be dtype float\\n rate_matrix = reaction_matrix.copy()\\n rate_matrix.dtype=np.float64\\n rate_matrix[reaction_matrix==1] = K\\n \\n positive_dcdt = rate_matrix.T.dot(C)\\n negative_dcdt = rate_matrix.T.sum(axis=0)*C\\n \\n return positive_dcdt - negative_dcdt\",\n \"def averageTime(self):\\n \\n pass\",\n \"def time_difference(time1: Time, time2: Time) -> float:\\n dsec = time1.sec - time2.sec\\n dnanosec = time1.nanosec - time2.nanosec\\n dt = dsec + dnanosec/(10**9)\\n return dt\",\n \"def cps(self):\\n return self.datacounts / self.exptime\",\n \"def dCadt(self, args: List[float]) -> float:\\n v, s_nmdar, ca = args\\n a_ca: float = self.params.a_ca\\n area: float = self.params.area\\n tau_ca: float= self.tau_ca\\n dCadt: float = (- a_ca * (10.0*area*self.cav.i(v))\\n - a_ca * self.nmdar.i(v, s=s_nmdar)\\n - ca / tau_ca)\\n return dCadt\",\n \"def duty_cycle(self):\\n diff = np.diff(self.lc.time)\\n t = np.median(diff)\\n std = np.std(diff)\\n mask = diff > (t + 3 * std)\\n return (1 - np.sum(diff[mask]) / np.sum(diff))\",\n \"def dY_dt(self, y, t=0):\\n\\t\\t \\n\\t\\t#variables\\n\\t\\tpSgg = y[0] / float(sum(y))\\n\\t\\tpSgh = y[3] / float(sum(y))\\n\\t\\tpSh = y[3] / float(y[3] + y[4] + y[5])\\n\\t\\t\\n\\t\\t#exit flows\\n\\t\\texit_Sg = y[0] * (1 / time_active) * t \\n\\t\\texit_Pg = y[1] * (1 / time_active) * t\\n\\t\\texit_PPg = y[2] * (1 / time_active) * t\\n\\t\\texit_Sh = y[3] * (1 / time_active) * t\\n\\t\\texit_Ph = y[4] * (1 / time_active) * t\\n\\t\\texit_PPh = y[5] * (1 / time_active) * t\\n\\t\\t#episodic flows\\n\\t\\tSg_to_h = y[0] * (1 / tin_g) * t\\n\\t\\tPg_to_h = y[1] * (1 / tin_g) * t\\n\\t\\tPPg_to_h = y[2] * (1 / tin_g) * t\\n\\t\\tSh_to_g = y[3] * (1 / tin_h) * t\\n\\t\\tPh_to_g = y[4] * (1 / tin_h) * t\\n\\t\\tPPh_to_g = y[5] * (1 / tin_h) * t\\n\\t\\t#entry flows\\n\\t\\tinto_g = new_g * t\\n\\t\\tinto_h = new_h * t\\n\\t\\t#infection flows\\n\\t\\tnewinf_gg = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgg * t\\n\\t\\tnewinf_gh = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgh * t\\n\\t\\tnewinf_h = (y[4] * B1 + y[5] * B2) * Ch * pSh * t\\n\\t\\t#stage progression flows\\n\\t\\tPg_to_PPg = y[1] * D1 * t\\n\\t\\tPPg_to_d = y[2] * D2 * t\\n\\t\\tPh_to_PPh = y[4] * D1 * t\\n\\t\\tPPh_to_d = y[5] * D2 * t\\n\\t\\t\\t\\n\\t\\tstate = [- exit_Sg - newinf_gg - Sg_to_h + into_g + Sh_to_g,\\n\\t\\t\\t\\t - exit_Pg - Pg_to_PPg - Pg_to_h + newinf_gg + Ph_to_g,\\n\\t\\t\\t\\t - exit_PPg - PPg_to_d - PPg_to_h + Pg_to_PPg + PPh_to_g,\\n\\t\\t\\t\\t - exit_Sh - newinf_gh - newinf_h - Sh_to_g + into_h + Sg_to_h,\\n\\t\\t\\t\\t - exit_Ph - Ph_to_PPh - Ph_to_g + newinf_gh + newinf_h + Pg_to_h,\\n\\t\\t\\t\\t - exit_PPh - PPh_to_d - PPh_to_g + Ph_to_PPh + PPg_to_h]\\n\\t\\n\\t\\treturn state\",\n \"def pc_work_time_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.doaesprit_sptr_pc_work_time_avg(self)\",\n \"def transit_duration(rstar, logg, per, ecc):\\n # Replace large ecc values with 0.99\\n ecc = np.where(ecc > 0.99, 0.99, ecc)\\n # Convert logg and rstar into stellar mass\\n mstar = mstar_from_stellarprops(rstar, logg)\\n # Semi-major axis in AU\\n semia = mstar**(1.0/3.0) * (per/365.25)**(2.0/3.0)\\n # transit duration e=0 including pi/4 effect of cos(inc) dist\\n r_sun = 6.9598e10 # cm\\n au2cm = 1.49598e13 # 1 AU = 1.49598e13 cm\\n durat = (per*24.0) / 4.0 * (rstar*r_sun) / (semia*au2cm)\\n #transit duration e > 0\\n durat = durat * np.sqrt(1.0-ecc**2);\\n\\n return durat\",\n \"def timefactor(self, period):\\n\\t\\tdays = period.size() * self.daysinunit(period.unit)\\n\\t\\treturn float(days)/self.daysinbase\",\n \"def sectoFracYear(stime):\\n\\n ltime = convertCtimeToYdate(stime)\\n atemp = re.split(':', ltime)\\n year= int(atemp[0])\\n ydate = int(atemp[1])\\n hours = int(atemp[2])\\n minutes = int(atemp[3])\\n seconds = int(atemp[4])\\n \\n chk = 4.0 * int(0.25 * year)\\n if chk == year:\\n base = 366\\n else:\\n base = 365\\n \\n day = ydate + hours / 24.0 + minutes / 1440.0 + seconds / 86400.0\\n \\n return year + day / base\",\n \"def ctime(self): # real signature unknown; restored from __doc__\\r\\n pass\",\n \"def _calculate_runtime(self):\\n lines = self.file_dic['output'].splitlines()\\n start_time = datetime.strptime(lines[0].strip(), self.timestring_format)\\n fin_time = datetime.strptime(lines[-1].strip(), self.timestring_format)\\n dif = fin_time - start_time\\n self.date = fin_time.strftime('%d %b %Y')\\n self.runtime = dif.total_seconds()\",\n \"def diff_op(self, args: List[float], time: float) -> List[float]:\\n v, nK, ca = args\\n ca_args: List[float] = [v, ca]\\n dvdt: float = self.dvdt(args=args)\\n dnKdt: float = self.kvhh.dndt(v=v, n=nK)\\n dCadt: float = self.dCadt(args=ca_args)\\n return [dvdt, dnKdt, dCadt]\",\n \"def total_seconds(td):\\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6\",\n \"def _normalizeDeltaTime(self, dt : float) -> float:\\n return dt / self.tau\",\n \"def compute_dsc(self, original, shrinked):\\n for i in range(len(original)):\\n x, y = original[i]\\n orig = y-x\\n\\n a, b = shrinked[i]\\n new = b-a\\n\\n dsc = float(new/orig)\\n\\n return dsc\",\n \"def calc_time(self, distance):\\r\\n if distance < 400:\\r\\n return 2*math.sqrt(distance / 1406.25)\\r\\n else:\\r\\n distance -= 400\\r\\n return distance / 750 + 16 / 15\",\n \"def test_day_percentage_timedelta(self):\\n delta = timedelta(seconds=987654, microseconds=321)\\n day_percentage = utils.day_percentage(delta)\\n self.assertEqual(day_percentage, 11.431180559270834)\",\n \"def arithmetic_ret(self) -> float:\\n return float(np.log(self.tsdf).diff().mean() * self.periods_in_a_year)\",\n \"def normalize_times(time,dtstart,dtend):\\n time=np.datetime64(time)\\n dtstart=np.datetime64(dtstart)\\n dtend=np.datetime64(dtend)\\n time_range = (dtend - dtstart).astype('float64')\\n seconds_from_t0 = (time - dtstart).astype('float64')\\n return seconds_from_t0 / time_range\",\n \"def sct_numericdate(cls, d):\\n return (d-cls.SCT_EPOCH).total_seconds() / 60\",\n \"def dCadt(self, args: List[float]) -> float:\\n v, ca = args\\n a_Ca: float = self.params.a_ca\\n area: float = self.params.area\\n tau_Ca: float = self.tau_ca\\n dCadt: float = -a_Ca * (10.0*area*self.cav.i(v)) - ca/tau_Ca\\n return dCadt\",\n \"def seconds_elapsed(date1, date2):\\n return (date1 - date2).total_seconds()\",\n \"def calc_dtdc_star(tpbpc0, spec):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n # Create array of times per bandpass\\n dtpb = np.hstack(tpbpc0)\\n\\n Nbs = len(dtpb)\\n dcomp = np.zeros(Nbs) # completeness\\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def calc_a(dert__):\\n return dert__[[2, 3]] / dert__[1] # np.array([dy, dx]) / g\",\n \"def calc_total_course_duration(timestamps):\\n answer = timedelta()\\n \\n for times in timestamps:\\n m, s = times.split(':')\\n answer += timedelta(minutes=int(m), seconds=int(s))\\n \\n return datetime.strptime(str(answer), '%H:%M:%S').strftime('%H:%M:%S')\\n pass\",\n \"def time_division(annuli):\\n \\n time_div=np.empty(len(annuli),dtype=int)\\n for annulus in range(len(annuli)):\\n r = annuli[annulus]\\n time_div[annulus]=int(viscous_timescale(r) * sample_ratio)\\n return time_div\",\n \"def get_elapsed_time(start, end):\\n return \\\"%s days, %s hours, %s minutes, %s seconds\\\" % dhms_from_seconds(date_diff_in_seconds(start, end))\",\n \"def test_cdf_vs_dt_cy():\\n burstsph, _ = load_burstsph()\\n ns = 1.0\\n nm = 1.0\\n δt = 1e-2 * ns\\n R0 = 6 * nm\\n R_mean = 6.5 * nm\\n R_sigma = 1 * nm\\n τ_relax = 0.2 * ns\\n τ_D = 4. * ns\\n k_D = 1. / τ_D\\n D_fract = np.atleast_1d(1.)\\n ts = burstsph.timestamp.values[:100000]\\n rg = RandomGenerator(Xoroshiro128(1))\\n R_ph, T_ph = depi_cy.sim_DA_from_timestamps2_p_cy(\\n ts, δt, k_D, R0, R_mean, R_sigma, τ_relax, rg, ndt=0, alpha=np.inf)\\n rg = RandomGenerator(Xoroshiro128(1))\\n R_php, T_php = depi_cy.sim_DA_from_timestamps2_p2_cy(\\n ts, δt, np.atleast_1d(k_D), D_fract, R0, R_mean, R_sigma, τ_relax, rg=rg,\\n ndt=0, alpha=np.inf)\\n assert not all([not np.allclose(R_ph, R_php),\\n not np.allclose(T_ph, T_php)])\",\n \"def mdct(x, odd=True):\\n return numpy.real(cmdct(x, odd=odd)) * numpy.sqrt(2)\",\n \"def total_time(self):\\n obs_times = self.clean_obs_times()\\n return _np.sum(obs_times[:, 1] - obs_times[:, 0])\",\n \"def trip_duration_stats(df):\\n\\n print('\\\\nCalculating Trip Duration...\\\\n')\\n start_time = time.time()\\n\\n # TO DO: display total travel time\\n\\n total_travel_time_in_sec = df['Trip Duration'].sum()\\n total_travel_time_in_years = total_travel_time_in_sec // (60 * 60 * 24 *365)\\n\\n modulus1_in_sec = total_travel_time_in_sec - total_travel_time_in_years*(60 * 60 * 24 *365)\\n #print(\\\"modulus1_in_sec:\\\", modulus1_in_sec)\\n total_travel_time_in_months = modulus1_in_sec // (60 * 60 * 24 *31)\\n\\n modulus2_in_sec = modulus1_in_sec - total_travel_time_in_months*(60 * 60 * 24 *31)\\n #print(\\\"modulus2_in_sec:\\\", modulus2_in_sec)\\n total_travel_time_in_weeks = modulus2_in_sec // (60 * 60 * 24 *7)\\n\\n modulus3_in_sec = modulus2_in_sec - total_travel_time_in_weeks*(60 * 60 * 24 *7)\\n #print(\\\"modulus3_in_sec:\\\", modulus3_in_sec)\\n total_travel_time_in_days = modulus3_in_sec // (60 * 60 * 24)\\n\\n modulus4_in_sec = modulus3_in_sec - total_travel_time_in_days*(60 * 60 * 24)\\n #print(\\\"modulus4_in_sec:\\\", modulus4_in_sec)\\n total_travel_time_in_hours = modulus4_in_sec // (60 * 60)\\n\\n modulus5_in_sec = modulus4_in_sec - total_travel_time_in_hours*(60 * 60)\\n #print(\\\"modulus5_in_sec:\\\", modulus5_in_sec)\\n total_travel_time_in_minutes = modulus5_in_sec // 60\\n\\n modulus6_in_sec = modulus5_in_sec - total_travel_time_in_minutes*60\\n #print(\\\"modulus6_in_sec:\\\", modulus6_in_sec)\\n total_travel_time_in_seconds_modulus = modulus6_in_sec\\n\\n print(\\\"total travel time of all Users combined:\\\\n YEARS: {} \\\\n MONTHS: {} \\\\n WEEKS: {} \\\\n DAYS: {} \\\\n HOURS: {} \\\\n MINUTES: {} \\\\n SECONDS: {} \\\\n\\\".format(total_travel_time_in_years, total_travel_time_in_months, total_travel_time_in_weeks, total_travel_time_in_days, total_travel_time_in_hours, total_travel_time_in_minutes, total_travel_time_in_seconds_modulus))\\n\\n # TO DO: display mean travel time\\n\\n mean_travel_time_in_sec = df['Trip Duration'].mean()\\n mean_travel_time_in_minutes = mean_travel_time_in_sec // 60\\n modulus_in_sec = mean_travel_time_in_sec - mean_travel_time_in_minutes*60\\n mean_travel_time_in_seconds_modulus = modulus_in_sec\\n\\n print(\\\"mean travel time:\\\\n MINUTES: {} \\\\n SECONDS: {} \\\\n\\\".format(int(mean_travel_time_in_minutes), mean_travel_time_in_seconds_modulus))\\n\\n#trip_duration_stats(pd.read_csv('{}.csv'.format(city)))\\n\\n print(\\\"\\\\nThis took %s seconds.\\\" % (time.time() - start_time))\\n print('-'*40)\",\n \"def discharge_date_time(subject_id, conn):\\n cur = conn.cursor()\\n sql = \\\"\\\"\\\"SELECT ED_DEPARTURE_TIME, EDDisposition FROM DEMOGRAPHICS\\n WHERE STUDYID = {}\\\"\\\"\\\".format(subject_id)\\n cur.execute(sql)\\n data = cur.fetchall()\\n if data[0][0]: # subjects who were discharged from the ED\\n date, time = data[0][0].split(\\\" \\\")\\n dispo = data[0][1]\\n return date, time, 'discharge', dispo\\n else: # Subjects who were admitted\\n sql = \\\"\\\"\\\"SELECT HOSP_ADMSN_TIME, EDDisposition FROM DEMOGRAPHICS\\n WHERE STUDYID = {}\\\"\\\"\\\".format(subject_id)\\n cur.execute(sql)\\n data = cur.fetchall()\\n if data[0][0]:\\n date, time = data[0][0].split(\\\" \\\")\\n dispo = data[0][1]\\n return date, time, 'discharge', dispo\",\n \"def t_conv_func(t_end,t_start,input_type='datetime',output_units='hours'):\\n if input_type == \\\"datetime\\\":\\n diff = (t_end-t_start).total_seconds ()\\n elif input_type == \\\"seconds\\\":\\n diff = t_end-t_start\\n else:\\n raise NotImplementedError\\n\\n if output_units == 'seconds':\\n return diff\\n elif output_units == 'minutes':\\n return diff/60.0\\n elif output_units == 'hours':\\n return diff/3600.0\\n else:\\n raise NotImplementedError\",\n \"def pc_work_time_avg(self):\\n return _spacegrant_swig.hdlc_deframer_sptr_pc_work_time_avg(self)\",\n \"def d_dt(self, r, t):\\n return self.d_do(r,t) * do_dt(r,t)\",\n \"def discretize(self,dt):\\n res = self.discretize_state(dt)\\n n = len(res.milestones[0])//2\\n return Trajectory(res.times,[m[:n] for m in res.milestones])\",\n \"def get_dt_per_index(self):\\n dt = self.data[1,-1] - self.data[0,-1]\\n return dt\",\n \"def dd2sec(dd):\\n minute, second = divmod(abs(dd) * 3600, 60)\\n degree, minute = divmod(minute, 60)\\n sec = (degree * 3600) + (minute * 60) + second\\n return sec if dd >= 0 else -sec\",\n \"def get_duration(self):\\n return float(self.time.iloc[-1] - self.time.iloc[0])\",\n \"def calculer_energie_cinetique_tnt(energie_cinetique):\\n return energie_cinetique / 4184\",\n \"def __call__(self):\\n \\n if self.funciona:\\n t = self.timeFunc() - self.t0 - self.retraso\\n elif self.t0!=None:\\n t = self.parada - self.t0 - self.retraso\\n else:\\n t = None\\n return t\",\n \"def period(self) -> int:\",\n \"def _steps_to_seconds(steps, qpm):\\n return steps * 60.0 / qpm / get_steps_per_quarter()\",\n \"def advantage(cpu_dt, gpu_dt):\\n assert gpu_dt >= 0 and cpu_dt >= 0\\n if gpu_dt == 0 and cpu_dt == 0:\\n return numpy.nan\\n elif gpu_dt == 0:\\n return numpy.inf\\n else:\\n return cpu_dt / gpu_dt\",\n \"def advantage(cpu_dt, gpu_dt):\\r\\n assert gpu_dt >= 0 and cpu_dt >= 0\\r\\n if gpu_dt == 0 and cpu_dt == 0:\\r\\n return numpy.nan\\r\\n elif gpu_dt == 0:\\r\\n return numpy.inf\\r\\n else:\\r\\n return cpu_dt / gpu_dt\",\n \"def REAL_TIME_ADVANCE(dt):\",\n \"def _STEPS2TIME(step):\\n return step/1000.\",\n \"def get_dtc(self):\\n r = self.sensor(1)\\n num = r[0]\\n # get all DTC, 3 per mesg response\\n self.send_command(GET_DTC_COMMAND)\\n #for i in range(0, ceil(num/3.0)):\\n res = self.get_result()\\n print res\\n return res\\n # fixme: finish\",\n \"def dspmt(t):\\n t = np.asarray(t)\\n return spmt(t) - spmt(t - 1)\",\n \"def test_curriculum_progress(self):\\n student_id = '0104926787'\\n career_id = 44\\n curriculum_id = 1\\n career_plan = 4\\n expected_result = self._get_curriculum_progress()\\n actual_result = self.ucuenca.curriculum_progress(\\n student_id, career_id, curriculum_id, career_plan\\n )\\n self.assertEqual(actual_result, expected_result)\",\n \"def pc_work_time_total(self):\\n return _TestA_swig.cleanslate_sptr_pc_work_time_total(self)\",\n \"def ddm(self):\\n if self.positive:\\n return DDMAngle(self.degree, self.minute + (self.second/60))\\n else:\\n return -DDMAngle(self.degree, self.minute + (self.second/60))\",\n \"def dvdt(self, args: List[float]) -> float:\\n v, h_nav, n_kvhh, h_kva, m_kvsi, s_ampar, _, s_nmdar, s_gabar, ca = args\\n return ((-10.0*self.params.area \\n * (self.leak.i(v)\\n + self.nav.i(v, h=h_nav) \\n + self.kvhh.i(v, n=n_kvhh)\\n + self.kva.i(v, h=h_kva)\\n + self.kvsi.i(v, m=m_kvsi)\\n + self.cav.i(v)\\n + self.kca.i(v, ca=ca)\\n + self.nap.i(v)\\n + self.kir.i(v))\\n - (self.ampar.i(v, s=s_ampar)\\n + self.nmdar.i(v, s=s_nmdar)\\n + self.gabar.i(v, s=s_gabar))) \\n / (10.0*self.params.cm*self.params.area))\",\n \"def pc_work_time_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.phasedarray_sptr_pc_work_time_avg(self)\",\n \"def tt_ut1(self):\\n # return the delta time for the input date converted to days\\n return interpolate_delta_time(_delta_file, self.tide)\",\n \"def trip_duration_stats(df, city):\\r\\n\\r\\n print(\\\"\\\\n\\\" * 2 + '*' * 20)\\r\\n print('Calculating Trip Duration...\\\\n')\\r\\n start_time = time.time()\\r\\n \\r\\n # TO DO: display total travel time\\r\\n try:\\r\\n df['Time Delta'] = df['End Time'] - df['Start Time']\\r\\n total_time_delta = df['Time Delta'].sum()\\r\\n print('The total travel time :', total_time_delta)\\r\\n except Exeption as e:\\r\\n print('An exception has been occurred while displaying total travel time: {}'.format(e))\\r\\n \\r\\n # TO DO: display mean travel time\\r\\n try:\\r\\n total_mean = df['Time Delta'].mean()\\r\\n print('The mean travel time :', total_mean)\\r\\n except Exception as e:\\r\\n print('An exception has been occurred while displaying mean travel time: {}'.format(e))\\r\\n \\r\\n print(\\\"\\\\nThis took %s seconds.\\\" % (time.time() - start_time))\\r\\n print('*' * 20)\",\n \"def get_frac_secs(self):\\n return _uhd_swig.time_spec_t_get_frac_secs(self)\",\n \"def suspected_per_hour(self):\\r\\n return (3600.*(self.circ_suspected+self.strm_suspected\\r\\n +self.circ_failed+self.strm_failed))/self.current_uptime()\",\n \"def _compute_duration(self):\\n diff_float = 0\\n for ts_line in self:\\n if ts_line.x_start_date:\\n st_datetime = fields.Datetime.from_string(\\n ts_line.x_start_date)\\n # autocomplete date from start date\\n st_date_tz = fields.Datetime.context_timestamp(\\n self, st_datetime).date()\\n ts_line.date = st_date_tz\\n\\n # autocomplete name from start date\\n st_datetime_tz = fields.Datetime.context_timestamp(\\n self, st_datetime)\\n string_st_dt_tz = fields.Datetime.to_string(st_datetime_tz)\\n ts_line.name = ts_line.user_id.name + '/' + string_st_dt_tz\\n\\n en_datetime = fields.Datetime.from_string(\\n ts_line.x_end_date)\\n diff = en_datetime - st_datetime\\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\\n # del 1 hour for breaking lunch\\n diff_float = round(diff.total_seconds() / 3600.0, 2)-1\\n else:\\n diff_float = round(diff.total_seconds() / 3600.0, 2)\\n ts_line.unit_amount = diff_float\",\n \"def getDuration(self):\\n #return np.sum(self.subintinfo['TSUBINT']) #This is constant.\\n return np.sum(self.getSubintinfo('TSUBINT')) #This is constant.\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59847087","0.58669096","0.57550395","0.57550395","0.5598215","0.5565188","0.5560319","0.5546098","0.55023235","0.5496921","0.5495189","0.5454725","0.5453212","0.53904337","0.53737885","0.5367238","0.5349814","0.53281","0.53280526","0.5322929","0.53107786","0.5303747","0.5290677","0.52759373","0.5272084","0.52647233","0.52452296","0.522168","0.5214286","0.520541","0.52031124","0.51921594","0.5185507","0.51707757","0.51632816","0.51623374","0.5162237","0.51588625","0.5143942","0.51435274","0.5134838","0.51304656","0.512816","0.5128017","0.512559","0.51255715","0.5121654","0.51212186","0.511431","0.51130915","0.51093763","0.51079714","0.5103952","0.509876","0.5089094","0.50842506","0.5076365","0.507039","0.5070128","0.506663","0.5049738","0.50454956","0.5036579","0.50339115","0.50326234","0.50324154","0.5026539","0.50262177","0.50250393","0.5011441","0.50049454","0.50032675","0.49981934","0.49969903","0.49936754","0.49925777","0.49914664","0.49881068","0.49855006","0.49803582","0.49802962","0.49769846","0.4976957","0.4971837","0.49678957","0.49654692","0.49649993","0.4962303","0.4958802","0.49578086","0.4957622","0.4950842","0.49497765","0.49482736","0.49461007","0.49455816","0.49437496","0.49429712","0.49404627","0.49375835"],"string":"[\n \"0.59847087\",\n \"0.58669096\",\n \"0.57550395\",\n \"0.57550395\",\n \"0.5598215\",\n \"0.5565188\",\n \"0.5560319\",\n \"0.5546098\",\n \"0.55023235\",\n \"0.5496921\",\n \"0.5495189\",\n \"0.5454725\",\n \"0.5453212\",\n \"0.53904337\",\n \"0.53737885\",\n \"0.5367238\",\n \"0.5349814\",\n \"0.53281\",\n \"0.53280526\",\n \"0.5322929\",\n \"0.53107786\",\n \"0.5303747\",\n \"0.5290677\",\n \"0.52759373\",\n \"0.5272084\",\n \"0.52647233\",\n \"0.52452296\",\n \"0.522168\",\n \"0.5214286\",\n \"0.520541\",\n \"0.52031124\",\n \"0.51921594\",\n \"0.5185507\",\n \"0.51707757\",\n \"0.51632816\",\n \"0.51623374\",\n \"0.5162237\",\n \"0.51588625\",\n \"0.5143942\",\n \"0.51435274\",\n \"0.5134838\",\n \"0.51304656\",\n \"0.512816\",\n \"0.5128017\",\n \"0.512559\",\n \"0.51255715\",\n \"0.5121654\",\n \"0.51212186\",\n \"0.511431\",\n \"0.51130915\",\n \"0.51093763\",\n \"0.51079714\",\n \"0.5103952\",\n \"0.509876\",\n \"0.5089094\",\n \"0.50842506\",\n \"0.5076365\",\n \"0.507039\",\n \"0.5070128\",\n \"0.506663\",\n \"0.5049738\",\n \"0.50454956\",\n \"0.5036579\",\n \"0.50339115\",\n \"0.50326234\",\n \"0.50324154\",\n \"0.5026539\",\n \"0.50262177\",\n \"0.50250393\",\n \"0.5011441\",\n \"0.50049454\",\n \"0.50032675\",\n \"0.49981934\",\n \"0.49969903\",\n \"0.49936754\",\n \"0.49925777\",\n \"0.49914664\",\n \"0.49881068\",\n \"0.49855006\",\n \"0.49803582\",\n \"0.49802962\",\n \"0.49769846\",\n \"0.4976957\",\n \"0.4971837\",\n \"0.49678957\",\n \"0.49654692\",\n \"0.49649993\",\n \"0.4962303\",\n \"0.4958802\",\n \"0.49578086\",\n \"0.4957622\",\n \"0.4950842\",\n \"0.49497765\",\n \"0.49482736\",\n \"0.49461007\",\n \"0.49455816\",\n \"0.49437496\",\n \"0.49429712\",\n \"0.49404627\",\n \"0.49375835\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5310874"},"document_rank":{"kind":"string","value":"20"}}},{"rowIdx":12885,"cells":{"query":{"kind":"string","value":"calculate time course ddct divided by treated ddct"},"document":{"kind":"string","value":"def calculate_d4ct(self, pairs_dct=None):\n #a, b, c, d, e, f, g, h, i\n if pairs_dct is None:\n pairs_dct={\n 'D': 'A',\n 'G': 'A',\n 'E': 'B',\n 'H': 'B',\n 'F': 'C',\n 'I': 'C',\n }\n data = deepcopy(self.d3ct)\n results_dct = {}\n for cell_line, normalizer in list(pairs_dct.items()):\n cell_data = data.query('cell_line ==\"{}\"'.format(cell_line))\n norm_data = data.query('cell_line ==\"{}\"'.format(normalizer))\n cell_data.index = cell_data.index.droplevel('cell_line')\n norm_data.index = norm_data.index.droplevel('cell_line')\n results_dct[r\"$\\frac{{{}}}{{{}}}$\".format(cell_line, normalizer)] = cell_data / norm_data\n df = pandas.concat(results_dct)\n return df"},"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_ddct(self, baseline_time=0):\n\n if baseline_time == 0:\n baseline = self.baseline_data['dct'][0]\n\n elif baseline_time == 96:\n baseline = self.baseline_data['dct'][96]\n\n elif baseline_time == 'average':\n baseline = (self.baseline_data['dct'][0] + self.baseline_data['dct'][96]) / 2\n\n control =self.treatment_data.query('treatment == \"Control\"')['dct']\n tgf = self.treatment_data.query('treatment == \"TGFb\"')['dct']\n control.index = control.index.droplevel(1)\n tgf.index = tgf.index.droplevel(1)\n baseline.index = baseline.index.droplevel(1)\n\n time = control.columns\n\n tgf = pandas.concat([tgf[i]/baseline for i in tgf.columns], axis=1)\n control = pandas.concat([control[i]/baseline for i in control.columns], axis=1)\n\n control.columns = time\n tgf.columns = time\n\n control = pandas.DataFrame(control.stack())\n tgf = pandas.DataFrame(tgf.stack())\n control['treatment'] = 'Control'\n tgf['treatment'] = 'TGFb'\n df = pandas.concat([control, tgf]).reset_index()\n df.rename(columns={0: 'ddct'})\n return df","def timeFrac(t):\n\tlt = timeCalc(t)[1]\n\tunit = ['w', 'd', 'h', 'm', 's']\n\tmaxima = [0, 7.0, 24.0, 60.0, 60.0]\n\tfractions = [\"\", u\"\\xBC\", u\"\\u00BD\", u\"\\u00BE\", \"\"]\n\t#fractions = [\"0\", \"1/4\", \"1/2\", \"3/4\", \"0\"]\n\t# \t\t\t0\t\t1/4\t\t1/2\t\t3/4\t\n\tfor x, dp in enumerate(lt):\n\t\tif dp==0:\n\t\t\tcontinue\n\t\telse:\n\t\t\ta = dp\n\t\t\tb = 0\n\t\t\tfor y in range(x+1, len(lt)):\n\t\t\t\tb+= lt[y]/maxima[y]\n\t\t\tc = int(round(b, 1)//0.25)\n\t\t\tif b>0.8: \n\t\t\t\ta+=1\n\t\t\t\tb=0\n\t\t\t\tc=0\n\t\t\t#print \"a:{} b:{} c:{}, x:{}\".format(a, b, c, x)\n\t\t\t#d = u\"{}{}{}\".format(a, fractions[c]*(x>3), unit[x]) WHY THIS??\n\t\t\td = u\"{}{}{}\".format(a, fractions[c], unit[x])\n\t\t\treturn (d, (a, c, unit[x]))","def __div__(self, d):\r\n if isinstance(d, TimeInterface):\r\n return np.divide(np.array(self), np.array(d).astype(float))\r\n else:\r\n return np.divide(self, d)","def __div__(self, d):\r\n if isinstance(d, TimeInterface):\r\n return np.divide(np.array(self), np.array(d).astype(float))\r\n else:\r\n return np.divide(self, d)","def dechours(self, yr, mn, d, t):\n dt = datetime(int(yr), int(mn), int(d))\n if self.epochhours == 0:\n self.epochhours = self.datehours(dt)\n\n e = self.datehours(dt)\n result=-1.0\n if len(t) > 0:\n (h, m) = t.split(':')\n fh = float(h)\n fm = float(m)\n r = fh + fm/60.0\n result = e + round(r, 2)\n\n # print \"dechours: \" + str(result) + \" yr=\" + str(yr) + \" mn=\" + str(mn) + \" d=\" + str(d) + \" \" + t\n return result","def get_timediv(self):\n result = self.bus.ask('HOR:MAI:SCA?')\n return float(result.rstrip())","def dCdt(t,C,params_unknown, params_known, i):\r\n q_co2_interp,P0,C0,a,b,c,P = params_known\r\n d,M0 = params_unknown\r\n return (1-C)*q_co2_interp[i]/M0 -b/a/M0*(P[i]-P0)*(carbon_prime(C,P[i],P0)-C)-d*(C-C0)","def utility_time_score(self, g, w):\n occ = parse_time(g.occurred)\n iss = parse_time(w.submitted)\n diff = occ - iss\n return diff.total_seconds() / 86400","def dvdt(self, args: List[float]) -> float:\n v, n_kvhh, ca = args\n return ((-10.0*self.params.area \n * (self.kvhh.i(v, n=n_kvhh) \n + self.cav.i(v) \n + self.kca.i(v, ca=ca) \n + self.nap.i(v) \n + self.leak.i(v))) \n / (10.0*self.params.cm*self.params.area))","def ddspmt(t):\n return (spmt(t) - _spm_dd_func(t)) / 0.01","def part2(input):\n ps = PlanetSystem(input)\n c = ps.total_cycle_time()\n return c","def duration(self):\r\n return self.t2 - self.t1","def margin_timed(self):\n sp = self.sale_price_timed or zero\n if u.isempty(sp):\n return zero\n cp = self.cost_price or zero\n return u.decimal((um-(cp/sp))*cem, True)","def divs(cps):\n # Head of unit\n mask = cps['tc3_p'] > 0\n cps_valid = cps[mask]\n rand = np.random.uniform(size=len(cps_valid))\n new_vals = np.exp(10.5 + 1. * rand)\n new_vals = np.where(new_vals < 20000., 20000., new_vals)\n cps.loc[mask, 'dbep'] = new_vals\n # spouse of unit\n mask = cps['tc3_s'] > 0\n cps_valid = cps[mask]\n rand = np.random.uniform(size=len(cps_valid))\n new_vals = np.exp(10.5 + 1. * rand)\n new_vals = np.where(new_vals < 20000., 20000., new_vals)\n cps.loc[mask, 'dbes'] = new_vals","def elapsed_time(date_1, date_2, dtype):\n days_in_year = 365.\n return tf.cast(date_1.days_until(date_2), dtype=dtype) / (\n days_in_year)","def do_dt(r, t):\n return -o(r,t)/(2*t)","def dd2dms(dd):\r\n mnt,sec = divmod(dd*3600,60)\r\n deg,mnt = divmod(mnt,60)\r\n return deg,mnt,sec","def dmstodec(decd,decm,decs):\n\tif decd < 0:\n\t decm = -1*decm\n\t decs = -1*decs\n\n\tdecdegs = float(decd)+(float(decm)/60)+(float(decs)/3600.0)\n\n\tif abs(decdegs) > 90:\n\t raise ValueError\n\n\treturn decdegs","def compute_duty_factor():\n [time,\n ankle_l_trajectory,\n ankle_r_trajectory,\n foot_l_contact,\n foot_r_contact,\n muscle_lh_activations,\n muscle_rh_activations,\n muscle_lh_forces,\n muscle_rh_forces,\n joint_lh_positions,\n joint_rh_positions] = load_data()\n \n print(np.sum(foot_l_contact)/len(foot_l_contact))\n print(np.sum(foot_r_contact)/len(foot_r_contact))\n\n return np.sum(foot_l_contact)/len(foot_l_contact)*0.5 + np.sum(foot_r_contact)/len(foot_r_contact)*0.5","def dydt_div(y, t, alpha, mu):\n X, U, Y, V = y\n dXdt = U\n dYdt = V\n R2 = X**2 + Y**2\n # Gas flow diverges from point (X1, Y1) = (1/mu, 0)\n X1, Y1 = 1.0/mu, 0.0\n # Gas flow is radial from that point\n R1 = np.hypot(X - X1, Y - Y1)\n U1 = (X - X1)/R1\n V1 = (Y - Y1)/R1\n theta = np.arctan2(Y, X)\n dUdt = 0.5*(np.cos(theta)/R2 - alpha**2 * (U - U1))\n dVdt = 0.5*(np.sin(theta)/R2 - alpha**2 * (V - V1))\n return [dXdt, dUdt, dYdt, dVdt]","def calculate_d3ct(self):\n data = deepcopy(self.ddct)\n data = data.set_index(['cell_line', 'replicate', 'Assay', 'time', 'treatment'])\n control = data.query('treatment == \"Control\"')#.reset_index(drop=True)\n tgfb = data.query('treatment == \"TGFb\"')#.reset_index(drop=True)\n control.index = control.index.droplevel(4)\n tgfb.index = tgfb.index.droplevel(4)\n return tgfb / control","def GAME_TIME_ADVANCE(dt):","def calc_total_course_duration(timestamps):\n dt_conversion = [datetime.strptime(ts, '%M:%S') for ts in timestamps]\n baseline = datetime(1900, 1, 1, 0, 0, 0)\n for course_dt in dt_conversion:\n baseline = baseline + timedelta(minutes=course_dt.minute, seconds=course_dt.second) \n\n return baseline.strftime('%-H:%M:%S')","def dCadt(self, args: Dict) -> float:\n if self.channel_bool['cav']:\n i_cav: float = self.cav.i(args['v'])\n else:\n self.I_cav = 0\n\n if self.channel_bool['nmdar']:\n i_nmdar: float = self.nmdar.i(args['v'], s=args['s_nmdar'])\n else:\n i_nmdar: float = 0\n\n ca: float = args['ca']\n a_ca: float = self.params.a_ca\n area: float = self.params.area\n tau_ca: float = self.tau_ca\n dCadt: float = -a_ca * (10.0*area*i_cav) - a_ca*i_nmdar - ca/tau_ca\n return dCadt","def runtime_cal(start,end) :\n run_time = end - start\n mm = int(run_time/60)\n ss = round(run_time%60)\n return mm, ss","def pcr_delta_time_ms(pcr_t1, pcr_t2, offset = 0):\n return float(pcr_t2-pcr_t1)/90000.0 + offset","def f(t, v):\n dSdt = - (a * v[1] * v[0]) / N\n dUdt = (a * v[1] * v[0]) / N - c * v[1]\n dQdt = c * v[1] - b * v[2]\n dCdt = b * v[2]\n return [dSdt, dUdt, dQdt, dCdt]","def pc_work_time_avg(self):\n return _TestA_swig.cleanslate_sptr_pc_work_time_avg(self)","def t_sec(self):\n return self.t/self.parameters['time_conversion']","def calc_dtdc(tpbpcs, specs):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n Nbs = len(np.hstack(tpbpcs[0]))\n Ndraw = len(tpbpcs)\n\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\n\n for i in range(Ndraw):\n\n # Create array of times per bandpass\n dtpb[i,:] = np.hstack(tpbpcs[i])\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def compute_time_step():\n\n dt = Hydro.compute_time_step()\n\n return dt","def failed_per_hour(self):\r\n return (3600.*(self.circ_failed+self.strm_failed))/self.current_uptime()","def get_total_seconds(td):\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1e6) / 1e6","def get_tdelta(self, ch1: int, ch2: int) -> float:\n cmd = ':measure:deltatime? channel{0},channel{1}'.format(ch1, ch2)\n return float(self.query(cmd))","def _compute_duration_overtime(self):\n diff_float = 0\n for ts_line in self:\n if ts_line.x_start_date:\n st_datetime = fields.Datetime.from_string(\n ts_line.x_start_date)\n en_datetime = fields.Datetime.from_string(\n ts_line.x_end_date)\n diff = en_datetime - st_datetime\n if not ts_line.is_overtime:\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\n # del 1 hour for breaking lunch\n diff_float = round(\n diff.total_seconds() / 3600.0, 2)-1\n else:\n diff_float = round(diff.total_seconds() / 3600.0, 2)\n ts_line.x_is_per_diem = False\n ts_line.unit_amount = diff_float","def F_calctimescales(i, st, dm):\n mr = st.mn*dm.mxkg_v[i]/(st.mn+dm.mxkg_v[i]) # reduced mass, kg\n # containment time (orbits within Rs)\n t1 = c_yr2s( 2.7e-2 * m.pow(dm.mxkg_v[i]/st.mn,1.5) / (dm.sigx/1.e-55) ) # s \n # therm time\n tth1 = c_yr2s( 2.5e+5 * m.pow(dm.mxkg_v[i]/st.mn,2.) * m.pow(st.mn/mr,3.) / (dm.sigx/1.e-55) ) # s\n# tth2 = m.pow(dm.mxkg_v[i]/st.mn,2.) * pF / 6. / m.sqrt(2.) / st.Temp / st.nb / dm.sigx * m.pow(st.mn/mr,3.) \n tth2 = m.pow(dm.mxkg_v[i],2.)*st.mn*pF /4./m.sqrt(2.)/(st.nb*1.e+6)/dm.sigx_m/m.pow(st.mn,3.)/st.Eth\n tth = tth2\n print \"-- Time scales: t1=%.2e , tth=%.2e, tth1=%.2e, tth2=%.2e\" % (t1,tth,tth1,tth2)\n return t1, tth","def dCR_dt(pops, t=0):\n\n R = pops[0]\n C = pops[1]\n K = 10000000\n dRdt = r * R * (1-(R/K)) - a * R * C\n dCdt = -z * C + e * a * R * C\n\n return sc.array([dRdt, dCdt])","def lead_time_score(self, g, w):\n rep = parse_time(g.reported)\n iss = parse_time(w.submitted)\n diff = rep - iss\n return diff.total_seconds() / 86400","def dpTime():\n start_time = time.time()\n subjects = loadSubjects(SUBJECT_FILENAME)\n maxWork = 50\n answer = dpAdvisor(subjects, maxWork)\n end_time = time.time()\n printSubjects(answer)\n print 'Time taken: ', end_time - start_time\n return None","def dc_dt(self,C,t,K):\n \n # dc/dt built up by separately computing the positive and negative contributions.\n # In our example positive_dcdt = [0, k1[A], k2[B]] and negative_dcdt = [-k1[A],-k2[B],0]\n reaction_matrix = np.array(self.reaction_matrix,dtype=np.int)\n C = np.array(C)\n #K = np.array(K.valuesdict().values())\n\n # need to have the same number of rate parameters in K\n # as indicated in reaction_matrix!\n assert len(K) == np.sum(reaction_matrix)\n \n # need to be careful about dtypes:\n # reaction matrix dtype is int, rate matrix must be dtype float\n rate_matrix = reaction_matrix.copy()\n rate_matrix.dtype=np.float64\n rate_matrix[reaction_matrix==1] = K\n \n positive_dcdt = rate_matrix.T.dot(C)\n negative_dcdt = rate_matrix.T.sum(axis=0)*C\n \n return positive_dcdt - negative_dcdt","def averageTime(self):\n \n pass","def time_difference(time1: Time, time2: Time) -> float:\n dsec = time1.sec - time2.sec\n dnanosec = time1.nanosec - time2.nanosec\n dt = dsec + dnanosec/(10**9)\n return dt","def dCadt(self, args: List[float]) -> float:\n v, s_nmdar, ca = args\n a_ca: float = self.params.a_ca\n area: float = self.params.area\n tau_ca: float= self.tau_ca\n dCadt: float = (- a_ca * (10.0*area*self.cav.i(v))\n - a_ca * self.nmdar.i(v, s=s_nmdar)\n - ca / tau_ca)\n return dCadt","def cps(self):\n return self.datacounts / self.exptime","def duty_cycle(self):\n diff = np.diff(self.lc.time)\n t = np.median(diff)\n std = np.std(diff)\n mask = diff > (t + 3 * std)\n return (1 - np.sum(diff[mask]) / np.sum(diff))","def dY_dt(self, y, t=0):\n\t\t \n\t\t#variables\n\t\tpSgg = y[0] / float(sum(y))\n\t\tpSgh = y[3] / float(sum(y))\n\t\tpSh = y[3] / float(y[3] + y[4] + y[5])\n\t\t\n\t\t#exit flows\n\t\texit_Sg = y[0] * (1 / time_active) * t \n\t\texit_Pg = y[1] * (1 / time_active) * t\n\t\texit_PPg = y[2] * (1 / time_active) * t\n\t\texit_Sh = y[3] * (1 / time_active) * t\n\t\texit_Ph = y[4] * (1 / time_active) * t\n\t\texit_PPh = y[5] * (1 / time_active) * t\n\t\t#episodic flows\n\t\tSg_to_h = y[0] * (1 / tin_g) * t\n\t\tPg_to_h = y[1] * (1 / tin_g) * t\n\t\tPPg_to_h = y[2] * (1 / tin_g) * t\n\t\tSh_to_g = y[3] * (1 / tin_h) * t\n\t\tPh_to_g = y[4] * (1 / tin_h) * t\n\t\tPPh_to_g = y[5] * (1 / tin_h) * t\n\t\t#entry flows\n\t\tinto_g = new_g * t\n\t\tinto_h = new_h * t\n\t\t#infection flows\n\t\tnewinf_gg = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgg * t\n\t\tnewinf_gh = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgh * t\n\t\tnewinf_h = (y[4] * B1 + y[5] * B2) * Ch * pSh * t\n\t\t#stage progression flows\n\t\tPg_to_PPg = y[1] * D1 * t\n\t\tPPg_to_d = y[2] * D2 * t\n\t\tPh_to_PPh = y[4] * D1 * t\n\t\tPPh_to_d = y[5] * D2 * t\n\t\t\t\n\t\tstate = [- exit_Sg - newinf_gg - Sg_to_h + into_g + Sh_to_g,\n\t\t\t\t - exit_Pg - Pg_to_PPg - Pg_to_h + newinf_gg + Ph_to_g,\n\t\t\t\t - exit_PPg - PPg_to_d - PPg_to_h + Pg_to_PPg + PPh_to_g,\n\t\t\t\t - exit_Sh - newinf_gh - newinf_h - Sh_to_g + into_h + Sg_to_h,\n\t\t\t\t - exit_Ph - Ph_to_PPh - Ph_to_g + newinf_gh + newinf_h + Pg_to_h,\n\t\t\t\t - exit_PPh - PPh_to_d - PPh_to_g + Ph_to_PPh + PPg_to_h]\n\t\n\t\treturn state","def pc_work_time_avg(self) -> \"float\":\n return _beamforming_swig.doaesprit_sptr_pc_work_time_avg(self)","def timefactor(self, period):\n\t\tdays = period.size() * self.daysinunit(period.unit)\n\t\treturn float(days)/self.daysinbase","def transit_duration(rstar, logg, per, ecc):\n # Replace large ecc values with 0.99\n ecc = np.where(ecc > 0.99, 0.99, ecc)\n # Convert logg and rstar into stellar mass\n mstar = mstar_from_stellarprops(rstar, logg)\n # Semi-major axis in AU\n semia = mstar**(1.0/3.0) * (per/365.25)**(2.0/3.0)\n # transit duration e=0 including pi/4 effect of cos(inc) dist\n r_sun = 6.9598e10 # cm\n au2cm = 1.49598e13 # 1 AU = 1.49598e13 cm\n durat = (per*24.0) / 4.0 * (rstar*r_sun) / (semia*au2cm)\n #transit duration e > 0\n durat = durat * np.sqrt(1.0-ecc**2);\n\n return durat","def sectoFracYear(stime):\n\n ltime = convertCtimeToYdate(stime)\n atemp = re.split(':', ltime)\n year= int(atemp[0])\n ydate = int(atemp[1])\n hours = int(atemp[2])\n minutes = int(atemp[3])\n seconds = int(atemp[4])\n \n chk = 4.0 * int(0.25 * year)\n if chk == year:\n base = 366\n else:\n base = 365\n \n day = ydate + hours / 24.0 + minutes / 1440.0 + seconds / 86400.0\n \n return year + day / base","def ctime(self): # real signature unknown; restored from __doc__\r\n pass","def diff_op(self, args: List[float], time: float) -> List[float]:\n v, nK, ca = args\n ca_args: List[float] = [v, ca]\n dvdt: float = self.dvdt(args=args)\n dnKdt: float = self.kvhh.dndt(v=v, n=nK)\n dCadt: float = self.dCadt(args=ca_args)\n return [dvdt, dnKdt, dCadt]","def _calculate_runtime(self):\n lines = self.file_dic['output'].splitlines()\n start_time = datetime.strptime(lines[0].strip(), self.timestring_format)\n fin_time = datetime.strptime(lines[-1].strip(), self.timestring_format)\n dif = fin_time - start_time\n self.date = fin_time.strftime('%d %b %Y')\n self.runtime = dif.total_seconds()","def total_seconds(td):\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6","def _normalizeDeltaTime(self, dt : float) -> float:\n return dt / self.tau","def compute_dsc(self, original, shrinked):\n for i in range(len(original)):\n x, y = original[i]\n orig = y-x\n\n a, b = shrinked[i]\n new = b-a\n\n dsc = float(new/orig)\n\n return dsc","def calc_time(self, distance):\r\n if distance < 400:\r\n return 2*math.sqrt(distance / 1406.25)\r\n else:\r\n distance -= 400\r\n return distance / 750 + 16 / 15","def test_day_percentage_timedelta(self):\n delta = timedelta(seconds=987654, microseconds=321)\n day_percentage = utils.day_percentage(delta)\n self.assertEqual(day_percentage, 11.431180559270834)","def arithmetic_ret(self) -> float:\n return float(np.log(self.tsdf).diff().mean() * self.periods_in_a_year)","def normalize_times(time,dtstart,dtend):\n time=np.datetime64(time)\n dtstart=np.datetime64(dtstart)\n dtend=np.datetime64(dtend)\n time_range = (dtend - dtstart).astype('float64')\n seconds_from_t0 = (time - dtstart).astype('float64')\n return seconds_from_t0 / time_range","def sct_numericdate(cls, d):\n return (d-cls.SCT_EPOCH).total_seconds() / 60","def dCadt(self, args: List[float]) -> float:\n v, ca = args\n a_Ca: float = self.params.a_ca\n area: float = self.params.area\n tau_Ca: float = self.tau_ca\n dCadt: float = -a_Ca * (10.0*area*self.cav.i(v)) - ca/tau_Ca\n return dCadt","def seconds_elapsed(date1, date2):\n return (date1 - date2).total_seconds()","def calc_dtdc_star(tpbpc0, spec):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n # Create array of times per bandpass\n dtpb = np.hstack(tpbpc0)\n\n Nbs = len(dtpb)\n dcomp = np.zeros(Nbs) # completeness\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def calc_a(dert__):\n return dert__[[2, 3]] / dert__[1] # np.array([dy, dx]) / g","def time_division(annuli):\n \n time_div=np.empty(len(annuli),dtype=int)\n for annulus in range(len(annuli)):\n r = annuli[annulus]\n time_div[annulus]=int(viscous_timescale(r) * sample_ratio)\n return time_div","def calc_total_course_duration(timestamps):\n answer = timedelta()\n \n for times in timestamps:\n m, s = times.split(':')\n answer += timedelta(minutes=int(m), seconds=int(s))\n \n return datetime.strptime(str(answer), '%H:%M:%S').strftime('%H:%M:%S')\n pass","def get_elapsed_time(start, end):\n return \"%s days, %s hours, %s minutes, %s seconds\" % dhms_from_seconds(date_diff_in_seconds(start, end))","def test_cdf_vs_dt_cy():\n burstsph, _ = load_burstsph()\n ns = 1.0\n nm = 1.0\n δt = 1e-2 * ns\n R0 = 6 * nm\n R_mean = 6.5 * nm\n R_sigma = 1 * nm\n τ_relax = 0.2 * ns\n τ_D = 4. * ns\n k_D = 1. / τ_D\n D_fract = np.atleast_1d(1.)\n ts = burstsph.timestamp.values[:100000]\n rg = RandomGenerator(Xoroshiro128(1))\n R_ph, T_ph = depi_cy.sim_DA_from_timestamps2_p_cy(\n ts, δt, k_D, R0, R_mean, R_sigma, τ_relax, rg, ndt=0, alpha=np.inf)\n rg = RandomGenerator(Xoroshiro128(1))\n R_php, T_php = depi_cy.sim_DA_from_timestamps2_p2_cy(\n ts, δt, np.atleast_1d(k_D), D_fract, R0, R_mean, R_sigma, τ_relax, rg=rg,\n ndt=0, alpha=np.inf)\n assert not all([not np.allclose(R_ph, R_php),\n not np.allclose(T_ph, T_php)])","def mdct(x, odd=True):\n return numpy.real(cmdct(x, odd=odd)) * numpy.sqrt(2)","def total_time(self):\n obs_times = self.clean_obs_times()\n return _np.sum(obs_times[:, 1] - obs_times[:, 0])","def trip_duration_stats(df):\n\n print('\\nCalculating Trip Duration...\\n')\n start_time = time.time()\n\n # TO DO: display total travel time\n\n total_travel_time_in_sec = df['Trip Duration'].sum()\n total_travel_time_in_years = total_travel_time_in_sec // (60 * 60 * 24 *365)\n\n modulus1_in_sec = total_travel_time_in_sec - total_travel_time_in_years*(60 * 60 * 24 *365)\n #print(\"modulus1_in_sec:\", modulus1_in_sec)\n total_travel_time_in_months = modulus1_in_sec // (60 * 60 * 24 *31)\n\n modulus2_in_sec = modulus1_in_sec - total_travel_time_in_months*(60 * 60 * 24 *31)\n #print(\"modulus2_in_sec:\", modulus2_in_sec)\n total_travel_time_in_weeks = modulus2_in_sec // (60 * 60 * 24 *7)\n\n modulus3_in_sec = modulus2_in_sec - total_travel_time_in_weeks*(60 * 60 * 24 *7)\n #print(\"modulus3_in_sec:\", modulus3_in_sec)\n total_travel_time_in_days = modulus3_in_sec // (60 * 60 * 24)\n\n modulus4_in_sec = modulus3_in_sec - total_travel_time_in_days*(60 * 60 * 24)\n #print(\"modulus4_in_sec:\", modulus4_in_sec)\n total_travel_time_in_hours = modulus4_in_sec // (60 * 60)\n\n modulus5_in_sec = modulus4_in_sec - total_travel_time_in_hours*(60 * 60)\n #print(\"modulus5_in_sec:\", modulus5_in_sec)\n total_travel_time_in_minutes = modulus5_in_sec // 60\n\n modulus6_in_sec = modulus5_in_sec - total_travel_time_in_minutes*60\n #print(\"modulus6_in_sec:\", modulus6_in_sec)\n total_travel_time_in_seconds_modulus = modulus6_in_sec\n\n print(\"total travel time of all Users combined:\\n YEARS: {} \\n MONTHS: {} \\n WEEKS: {} \\n DAYS: {} \\n HOURS: {} \\n MINUTES: {} \\n SECONDS: {} \\n\".format(total_travel_time_in_years, total_travel_time_in_months, total_travel_time_in_weeks, total_travel_time_in_days, total_travel_time_in_hours, total_travel_time_in_minutes, total_travel_time_in_seconds_modulus))\n\n # TO DO: display mean travel time\n\n mean_travel_time_in_sec = df['Trip Duration'].mean()\n mean_travel_time_in_minutes = mean_travel_time_in_sec // 60\n modulus_in_sec = mean_travel_time_in_sec - mean_travel_time_in_minutes*60\n mean_travel_time_in_seconds_modulus = modulus_in_sec\n\n print(\"mean travel time:\\n MINUTES: {} \\n SECONDS: {} \\n\".format(int(mean_travel_time_in_minutes), mean_travel_time_in_seconds_modulus))\n\n#trip_duration_stats(pd.read_csv('{}.csv'.format(city)))\n\n print(\"\\nThis took %s seconds.\" % (time.time() - start_time))\n print('-'*40)","def discharge_date_time(subject_id, conn):\n cur = conn.cursor()\n sql = \"\"\"SELECT ED_DEPARTURE_TIME, EDDisposition FROM DEMOGRAPHICS\n WHERE STUDYID = {}\"\"\".format(subject_id)\n cur.execute(sql)\n data = cur.fetchall()\n if data[0][0]: # subjects who were discharged from the ED\n date, time = data[0][0].split(\" \")\n dispo = data[0][1]\n return date, time, 'discharge', dispo\n else: # Subjects who were admitted\n sql = \"\"\"SELECT HOSP_ADMSN_TIME, EDDisposition FROM DEMOGRAPHICS\n WHERE STUDYID = {}\"\"\".format(subject_id)\n cur.execute(sql)\n data = cur.fetchall()\n if data[0][0]:\n date, time = data[0][0].split(\" \")\n dispo = data[0][1]\n return date, time, 'discharge', dispo","def t_conv_func(t_end,t_start,input_type='datetime',output_units='hours'):\n if input_type == \"datetime\":\n diff = (t_end-t_start).total_seconds ()\n elif input_type == \"seconds\":\n diff = t_end-t_start\n else:\n raise NotImplementedError\n\n if output_units == 'seconds':\n return diff\n elif output_units == 'minutes':\n return diff/60.0\n elif output_units == 'hours':\n return diff/3600.0\n else:\n raise NotImplementedError","def pc_work_time_avg(self):\n return _spacegrant_swig.hdlc_deframer_sptr_pc_work_time_avg(self)","def d_dt(self, r, t):\n return self.d_do(r,t) * do_dt(r,t)","def discretize(self,dt):\n res = self.discretize_state(dt)\n n = len(res.milestones[0])//2\n return Trajectory(res.times,[m[:n] for m in res.milestones])","def get_dt_per_index(self):\n dt = self.data[1,-1] - self.data[0,-1]\n return dt","def dd2sec(dd):\n minute, second = divmod(abs(dd) * 3600, 60)\n degree, minute = divmod(minute, 60)\n sec = (degree * 3600) + (minute * 60) + second\n return sec if dd >= 0 else -sec","def get_duration(self):\n return float(self.time.iloc[-1] - self.time.iloc[0])","def __call__(self):\n \n if self.funciona:\n t = self.timeFunc() - self.t0 - self.retraso\n elif self.t0!=None:\n t = self.parada - self.t0 - self.retraso\n else:\n t = None\n return t","def calculer_energie_cinetique_tnt(energie_cinetique):\n return energie_cinetique / 4184","def period(self) -> int:","def _steps_to_seconds(steps, qpm):\n return steps * 60.0 / qpm / get_steps_per_quarter()","def advantage(cpu_dt, gpu_dt):\n assert gpu_dt >= 0 and cpu_dt >= 0\n if gpu_dt == 0 and cpu_dt == 0:\n return numpy.nan\n elif gpu_dt == 0:\n return numpy.inf\n else:\n return cpu_dt / gpu_dt","def advantage(cpu_dt, gpu_dt):\r\n assert gpu_dt >= 0 and cpu_dt >= 0\r\n if gpu_dt == 0 and cpu_dt == 0:\r\n return numpy.nan\r\n elif gpu_dt == 0:\r\n return numpy.inf\r\n else:\r\n return cpu_dt / gpu_dt","def REAL_TIME_ADVANCE(dt):","def get_dtc(self):\n r = self.sensor(1)\n num = r[0]\n # get all DTC, 3 per mesg response\n self.send_command(GET_DTC_COMMAND)\n #for i in range(0, ceil(num/3.0)):\n res = self.get_result()\n print res\n return res\n # fixme: finish","def _STEPS2TIME(step):\n return step/1000.","def dspmt(t):\n t = np.asarray(t)\n return spmt(t) - spmt(t - 1)","def test_curriculum_progress(self):\n student_id = '0104926787'\n career_id = 44\n curriculum_id = 1\n career_plan = 4\n expected_result = self._get_curriculum_progress()\n actual_result = self.ucuenca.curriculum_progress(\n student_id, career_id, curriculum_id, career_plan\n )\n self.assertEqual(actual_result, expected_result)","def pc_work_time_total(self):\n return _TestA_swig.cleanslate_sptr_pc_work_time_total(self)","def ddm(self):\n if self.positive:\n return DDMAngle(self.degree, self.minute + (self.second/60))\n else:\n return -DDMAngle(self.degree, self.minute + (self.second/60))","def dvdt(self, args: List[float]) -> float:\n v, h_nav, n_kvhh, h_kva, m_kvsi, s_ampar, _, s_nmdar, s_gabar, ca = args\n return ((-10.0*self.params.area \n * (self.leak.i(v)\n + self.nav.i(v, h=h_nav) \n + self.kvhh.i(v, n=n_kvhh)\n + self.kva.i(v, h=h_kva)\n + self.kvsi.i(v, m=m_kvsi)\n + self.cav.i(v)\n + self.kca.i(v, ca=ca)\n + self.nap.i(v)\n + self.kir.i(v))\n - (self.ampar.i(v, s=s_ampar)\n + self.nmdar.i(v, s=s_nmdar)\n + self.gabar.i(v, s=s_gabar))) \n / (10.0*self.params.cm*self.params.area))","def tt_ut1(self):\n # return the delta time for the input date converted to days\n return interpolate_delta_time(_delta_file, self.tide)","def pc_work_time_avg(self) -> \"float\":\n return _beamforming_swig.phasedarray_sptr_pc_work_time_avg(self)","def trip_duration_stats(df, city):\r\n\r\n print(\"\\n\" * 2 + '*' * 20)\r\n print('Calculating Trip Duration...\\n')\r\n start_time = time.time()\r\n \r\n # TO DO: display total travel time\r\n try:\r\n df['Time Delta'] = df['End Time'] - df['Start Time']\r\n total_time_delta = df['Time Delta'].sum()\r\n print('The total travel time :', total_time_delta)\r\n except Exeption as e:\r\n print('An exception has been occurred while displaying total travel time: {}'.format(e))\r\n \r\n # TO DO: display mean travel time\r\n try:\r\n total_mean = df['Time Delta'].mean()\r\n print('The mean travel time :', total_mean)\r\n except Exception as e:\r\n print('An exception has been occurred while displaying mean travel time: {}'.format(e))\r\n \r\n print(\"\\nThis took %s seconds.\" % (time.time() - start_time))\r\n print('*' * 20)","def get_frac_secs(self):\n return _uhd_swig.time_spec_t_get_frac_secs(self)","def suspected_per_hour(self):\r\n return (3600.*(self.circ_suspected+self.strm_suspected\r\n +self.circ_failed+self.strm_failed))/self.current_uptime()","def _compute_duration(self):\n diff_float = 0\n for ts_line in self:\n if ts_line.x_start_date:\n st_datetime = fields.Datetime.from_string(\n ts_line.x_start_date)\n # autocomplete date from start date\n st_date_tz = fields.Datetime.context_timestamp(\n self, st_datetime).date()\n ts_line.date = st_date_tz\n\n # autocomplete name from start date\n st_datetime_tz = fields.Datetime.context_timestamp(\n self, st_datetime)\n string_st_dt_tz = fields.Datetime.to_string(st_datetime_tz)\n ts_line.name = ts_line.user_id.name + '/' + string_st_dt_tz\n\n en_datetime = fields.Datetime.from_string(\n ts_line.x_end_date)\n diff = en_datetime - st_datetime\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\n # del 1 hour for breaking lunch\n diff_float = round(diff.total_seconds() / 3600.0, 2)-1\n else:\n diff_float = round(diff.total_seconds() / 3600.0, 2)\n ts_line.unit_amount = diff_float","def getDuration(self):\n #return np.sum(self.subintinfo['TSUBINT']) #This is constant.\n return np.sum(self.getSubintinfo('TSUBINT')) #This is constant."],"string":"[\n \"def calculate_ddct(self, baseline_time=0):\\n\\n if baseline_time == 0:\\n baseline = self.baseline_data['dct'][0]\\n\\n elif baseline_time == 96:\\n baseline = self.baseline_data['dct'][96]\\n\\n elif baseline_time == 'average':\\n baseline = (self.baseline_data['dct'][0] + self.baseline_data['dct'][96]) / 2\\n\\n control =self.treatment_data.query('treatment == \\\"Control\\\"')['dct']\\n tgf = self.treatment_data.query('treatment == \\\"TGFb\\\"')['dct']\\n control.index = control.index.droplevel(1)\\n tgf.index = tgf.index.droplevel(1)\\n baseline.index = baseline.index.droplevel(1)\\n\\n time = control.columns\\n\\n tgf = pandas.concat([tgf[i]/baseline for i in tgf.columns], axis=1)\\n control = pandas.concat([control[i]/baseline for i in control.columns], axis=1)\\n\\n control.columns = time\\n tgf.columns = time\\n\\n control = pandas.DataFrame(control.stack())\\n tgf = pandas.DataFrame(tgf.stack())\\n control['treatment'] = 'Control'\\n tgf['treatment'] = 'TGFb'\\n df = pandas.concat([control, tgf]).reset_index()\\n df.rename(columns={0: 'ddct'})\\n return df\",\n \"def timeFrac(t):\\n\\tlt = timeCalc(t)[1]\\n\\tunit = ['w', 'd', 'h', 'm', 's']\\n\\tmaxima = [0, 7.0, 24.0, 60.0, 60.0]\\n\\tfractions = [\\\"\\\", u\\\"\\\\xBC\\\", u\\\"\\\\u00BD\\\", u\\\"\\\\u00BE\\\", \\\"\\\"]\\n\\t#fractions = [\\\"0\\\", \\\"1/4\\\", \\\"1/2\\\", \\\"3/4\\\", \\\"0\\\"]\\n\\t# \\t\\t\\t0\\t\\t1/4\\t\\t1/2\\t\\t3/4\\t\\n\\tfor x, dp in enumerate(lt):\\n\\t\\tif dp==0:\\n\\t\\t\\tcontinue\\n\\t\\telse:\\n\\t\\t\\ta = dp\\n\\t\\t\\tb = 0\\n\\t\\t\\tfor y in range(x+1, len(lt)):\\n\\t\\t\\t\\tb+= lt[y]/maxima[y]\\n\\t\\t\\tc = int(round(b, 1)//0.25)\\n\\t\\t\\tif b>0.8: \\n\\t\\t\\t\\ta+=1\\n\\t\\t\\t\\tb=0\\n\\t\\t\\t\\tc=0\\n\\t\\t\\t#print \\\"a:{} b:{} c:{}, x:{}\\\".format(a, b, c, x)\\n\\t\\t\\t#d = u\\\"{}{}{}\\\".format(a, fractions[c]*(x>3), unit[x]) WHY THIS??\\n\\t\\t\\td = u\\\"{}{}{}\\\".format(a, fractions[c], unit[x])\\n\\t\\t\\treturn (d, (a, c, unit[x]))\",\n \"def __div__(self, d):\\r\\n if isinstance(d, TimeInterface):\\r\\n return np.divide(np.array(self), np.array(d).astype(float))\\r\\n else:\\r\\n return np.divide(self, d)\",\n \"def __div__(self, d):\\r\\n if isinstance(d, TimeInterface):\\r\\n return np.divide(np.array(self), np.array(d).astype(float))\\r\\n else:\\r\\n return np.divide(self, d)\",\n \"def dechours(self, yr, mn, d, t):\\n dt = datetime(int(yr), int(mn), int(d))\\n if self.epochhours == 0:\\n self.epochhours = self.datehours(dt)\\n\\n e = self.datehours(dt)\\n result=-1.0\\n if len(t) > 0:\\n (h, m) = t.split(':')\\n fh = float(h)\\n fm = float(m)\\n r = fh + fm/60.0\\n result = e + round(r, 2)\\n\\n # print \\\"dechours: \\\" + str(result) + \\\" yr=\\\" + str(yr) + \\\" mn=\\\" + str(mn) + \\\" d=\\\" + str(d) + \\\" \\\" + t\\n return result\",\n \"def get_timediv(self):\\n result = self.bus.ask('HOR:MAI:SCA?')\\n return float(result.rstrip())\",\n \"def dCdt(t,C,params_unknown, params_known, i):\\r\\n q_co2_interp,P0,C0,a,b,c,P = params_known\\r\\n d,M0 = params_unknown\\r\\n return (1-C)*q_co2_interp[i]/M0 -b/a/M0*(P[i]-P0)*(carbon_prime(C,P[i],P0)-C)-d*(C-C0)\",\n \"def utility_time_score(self, g, w):\\n occ = parse_time(g.occurred)\\n iss = parse_time(w.submitted)\\n diff = occ - iss\\n return diff.total_seconds() / 86400\",\n \"def dvdt(self, args: List[float]) -> float:\\n v, n_kvhh, ca = args\\n return ((-10.0*self.params.area \\n * (self.kvhh.i(v, n=n_kvhh) \\n + self.cav.i(v) \\n + self.kca.i(v, ca=ca) \\n + self.nap.i(v) \\n + self.leak.i(v))) \\n / (10.0*self.params.cm*self.params.area))\",\n \"def ddspmt(t):\\n return (spmt(t) - _spm_dd_func(t)) / 0.01\",\n \"def part2(input):\\n ps = PlanetSystem(input)\\n c = ps.total_cycle_time()\\n return c\",\n \"def duration(self):\\r\\n return self.t2 - self.t1\",\n \"def margin_timed(self):\\n sp = self.sale_price_timed or zero\\n if u.isempty(sp):\\n return zero\\n cp = self.cost_price or zero\\n return u.decimal((um-(cp/sp))*cem, True)\",\n \"def divs(cps):\\n # Head of unit\\n mask = cps['tc3_p'] > 0\\n cps_valid = cps[mask]\\n rand = np.random.uniform(size=len(cps_valid))\\n new_vals = np.exp(10.5 + 1. * rand)\\n new_vals = np.where(new_vals < 20000., 20000., new_vals)\\n cps.loc[mask, 'dbep'] = new_vals\\n # spouse of unit\\n mask = cps['tc3_s'] > 0\\n cps_valid = cps[mask]\\n rand = np.random.uniform(size=len(cps_valid))\\n new_vals = np.exp(10.5 + 1. * rand)\\n new_vals = np.where(new_vals < 20000., 20000., new_vals)\\n cps.loc[mask, 'dbes'] = new_vals\",\n \"def elapsed_time(date_1, date_2, dtype):\\n days_in_year = 365.\\n return tf.cast(date_1.days_until(date_2), dtype=dtype) / (\\n days_in_year)\",\n \"def do_dt(r, t):\\n return -o(r,t)/(2*t)\",\n \"def dd2dms(dd):\\r\\n mnt,sec = divmod(dd*3600,60)\\r\\n deg,mnt = divmod(mnt,60)\\r\\n return deg,mnt,sec\",\n \"def dmstodec(decd,decm,decs):\\n\\tif decd < 0:\\n\\t decm = -1*decm\\n\\t decs = -1*decs\\n\\n\\tdecdegs = float(decd)+(float(decm)/60)+(float(decs)/3600.0)\\n\\n\\tif abs(decdegs) > 90:\\n\\t raise ValueError\\n\\n\\treturn decdegs\",\n \"def compute_duty_factor():\\n [time,\\n ankle_l_trajectory,\\n ankle_r_trajectory,\\n foot_l_contact,\\n foot_r_contact,\\n muscle_lh_activations,\\n muscle_rh_activations,\\n muscle_lh_forces,\\n muscle_rh_forces,\\n joint_lh_positions,\\n joint_rh_positions] = load_data()\\n \\n print(np.sum(foot_l_contact)/len(foot_l_contact))\\n print(np.sum(foot_r_contact)/len(foot_r_contact))\\n\\n return np.sum(foot_l_contact)/len(foot_l_contact)*0.5 + np.sum(foot_r_contact)/len(foot_r_contact)*0.5\",\n \"def dydt_div(y, t, alpha, mu):\\n X, U, Y, V = y\\n dXdt = U\\n dYdt = V\\n R2 = X**2 + Y**2\\n # Gas flow diverges from point (X1, Y1) = (1/mu, 0)\\n X1, Y1 = 1.0/mu, 0.0\\n # Gas flow is radial from that point\\n R1 = np.hypot(X - X1, Y - Y1)\\n U1 = (X - X1)/R1\\n V1 = (Y - Y1)/R1\\n theta = np.arctan2(Y, X)\\n dUdt = 0.5*(np.cos(theta)/R2 - alpha**2 * (U - U1))\\n dVdt = 0.5*(np.sin(theta)/R2 - alpha**2 * (V - V1))\\n return [dXdt, dUdt, dYdt, dVdt]\",\n \"def calculate_d3ct(self):\\n data = deepcopy(self.ddct)\\n data = data.set_index(['cell_line', 'replicate', 'Assay', 'time', 'treatment'])\\n control = data.query('treatment == \\\"Control\\\"')#.reset_index(drop=True)\\n tgfb = data.query('treatment == \\\"TGFb\\\"')#.reset_index(drop=True)\\n control.index = control.index.droplevel(4)\\n tgfb.index = tgfb.index.droplevel(4)\\n return tgfb / control\",\n \"def GAME_TIME_ADVANCE(dt):\",\n \"def calc_total_course_duration(timestamps):\\n dt_conversion = [datetime.strptime(ts, '%M:%S') for ts in timestamps]\\n baseline = datetime(1900, 1, 1, 0, 0, 0)\\n for course_dt in dt_conversion:\\n baseline = baseline + timedelta(minutes=course_dt.minute, seconds=course_dt.second) \\n\\n return baseline.strftime('%-H:%M:%S')\",\n \"def dCadt(self, args: Dict) -> float:\\n if self.channel_bool['cav']:\\n i_cav: float = self.cav.i(args['v'])\\n else:\\n self.I_cav = 0\\n\\n if self.channel_bool['nmdar']:\\n i_nmdar: float = self.nmdar.i(args['v'], s=args['s_nmdar'])\\n else:\\n i_nmdar: float = 0\\n\\n ca: float = args['ca']\\n a_ca: float = self.params.a_ca\\n area: float = self.params.area\\n tau_ca: float = self.tau_ca\\n dCadt: float = -a_ca * (10.0*area*i_cav) - a_ca*i_nmdar - ca/tau_ca\\n return dCadt\",\n \"def runtime_cal(start,end) :\\n run_time = end - start\\n mm = int(run_time/60)\\n ss = round(run_time%60)\\n return mm, ss\",\n \"def pcr_delta_time_ms(pcr_t1, pcr_t2, offset = 0):\\n return float(pcr_t2-pcr_t1)/90000.0 + offset\",\n \"def f(t, v):\\n dSdt = - (a * v[1] * v[0]) / N\\n dUdt = (a * v[1] * v[0]) / N - c * v[1]\\n dQdt = c * v[1] - b * v[2]\\n dCdt = b * v[2]\\n return [dSdt, dUdt, dQdt, dCdt]\",\n \"def pc_work_time_avg(self):\\n return _TestA_swig.cleanslate_sptr_pc_work_time_avg(self)\",\n \"def t_sec(self):\\n return self.t/self.parameters['time_conversion']\",\n \"def calc_dtdc(tpbpcs, specs):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n Nbs = len(np.hstack(tpbpcs[0]))\\n Ndraw = len(tpbpcs)\\n\\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\\n\\n for i in range(Ndraw):\\n\\n # Create array of times per bandpass\\n dtpb[i,:] = np.hstack(tpbpcs[i])\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def compute_time_step():\\n\\n dt = Hydro.compute_time_step()\\n\\n return dt\",\n \"def failed_per_hour(self):\\r\\n return (3600.*(self.circ_failed+self.strm_failed))/self.current_uptime()\",\n \"def get_total_seconds(td):\\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1e6) / 1e6\",\n \"def get_tdelta(self, ch1: int, ch2: int) -> float:\\n cmd = ':measure:deltatime? channel{0},channel{1}'.format(ch1, ch2)\\n return float(self.query(cmd))\",\n \"def _compute_duration_overtime(self):\\n diff_float = 0\\n for ts_line in self:\\n if ts_line.x_start_date:\\n st_datetime = fields.Datetime.from_string(\\n ts_line.x_start_date)\\n en_datetime = fields.Datetime.from_string(\\n ts_line.x_end_date)\\n diff = en_datetime - st_datetime\\n if not ts_line.is_overtime:\\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\\n # del 1 hour for breaking lunch\\n diff_float = round(\\n diff.total_seconds() / 3600.0, 2)-1\\n else:\\n diff_float = round(diff.total_seconds() / 3600.0, 2)\\n ts_line.x_is_per_diem = False\\n ts_line.unit_amount = diff_float\",\n \"def F_calctimescales(i, st, dm):\\n mr = st.mn*dm.mxkg_v[i]/(st.mn+dm.mxkg_v[i]) # reduced mass, kg\\n # containment time (orbits within Rs)\\n t1 = c_yr2s( 2.7e-2 * m.pow(dm.mxkg_v[i]/st.mn,1.5) / (dm.sigx/1.e-55) ) # s \\n # therm time\\n tth1 = c_yr2s( 2.5e+5 * m.pow(dm.mxkg_v[i]/st.mn,2.) * m.pow(st.mn/mr,3.) / (dm.sigx/1.e-55) ) # s\\n# tth2 = m.pow(dm.mxkg_v[i]/st.mn,2.) * pF / 6. / m.sqrt(2.) / st.Temp / st.nb / dm.sigx * m.pow(st.mn/mr,3.) \\n tth2 = m.pow(dm.mxkg_v[i],2.)*st.mn*pF /4./m.sqrt(2.)/(st.nb*1.e+6)/dm.sigx_m/m.pow(st.mn,3.)/st.Eth\\n tth = tth2\\n print \\\"-- Time scales: t1=%.2e , tth=%.2e, tth1=%.2e, tth2=%.2e\\\" % (t1,tth,tth1,tth2)\\n return t1, tth\",\n \"def dCR_dt(pops, t=0):\\n\\n R = pops[0]\\n C = pops[1]\\n K = 10000000\\n dRdt = r * R * (1-(R/K)) - a * R * C\\n dCdt = -z * C + e * a * R * C\\n\\n return sc.array([dRdt, dCdt])\",\n \"def lead_time_score(self, g, w):\\n rep = parse_time(g.reported)\\n iss = parse_time(w.submitted)\\n diff = rep - iss\\n return diff.total_seconds() / 86400\",\n \"def dpTime():\\n start_time = time.time()\\n subjects = loadSubjects(SUBJECT_FILENAME)\\n maxWork = 50\\n answer = dpAdvisor(subjects, maxWork)\\n end_time = time.time()\\n printSubjects(answer)\\n print 'Time taken: ', end_time - start_time\\n return None\",\n \"def dc_dt(self,C,t,K):\\n \\n # dc/dt built up by separately computing the positive and negative contributions.\\n # In our example positive_dcdt = [0, k1[A], k2[B]] and negative_dcdt = [-k1[A],-k2[B],0]\\n reaction_matrix = np.array(self.reaction_matrix,dtype=np.int)\\n C = np.array(C)\\n #K = np.array(K.valuesdict().values())\\n\\n # need to have the same number of rate parameters in K\\n # as indicated in reaction_matrix!\\n assert len(K) == np.sum(reaction_matrix)\\n \\n # need to be careful about dtypes:\\n # reaction matrix dtype is int, rate matrix must be dtype float\\n rate_matrix = reaction_matrix.copy()\\n rate_matrix.dtype=np.float64\\n rate_matrix[reaction_matrix==1] = K\\n \\n positive_dcdt = rate_matrix.T.dot(C)\\n negative_dcdt = rate_matrix.T.sum(axis=0)*C\\n \\n return positive_dcdt - negative_dcdt\",\n \"def averageTime(self):\\n \\n pass\",\n \"def time_difference(time1: Time, time2: Time) -> float:\\n dsec = time1.sec - time2.sec\\n dnanosec = time1.nanosec - time2.nanosec\\n dt = dsec + dnanosec/(10**9)\\n return dt\",\n \"def dCadt(self, args: List[float]) -> float:\\n v, s_nmdar, ca = args\\n a_ca: float = self.params.a_ca\\n area: float = self.params.area\\n tau_ca: float= self.tau_ca\\n dCadt: float = (- a_ca * (10.0*area*self.cav.i(v))\\n - a_ca * self.nmdar.i(v, s=s_nmdar)\\n - ca / tau_ca)\\n return dCadt\",\n \"def cps(self):\\n return self.datacounts / self.exptime\",\n \"def duty_cycle(self):\\n diff = np.diff(self.lc.time)\\n t = np.median(diff)\\n std = np.std(diff)\\n mask = diff > (t + 3 * std)\\n return (1 - np.sum(diff[mask]) / np.sum(diff))\",\n \"def dY_dt(self, y, t=0):\\n\\t\\t \\n\\t\\t#variables\\n\\t\\tpSgg = y[0] / float(sum(y))\\n\\t\\tpSgh = y[3] / float(sum(y))\\n\\t\\tpSh = y[3] / float(y[3] + y[4] + y[5])\\n\\t\\t\\n\\t\\t#exit flows\\n\\t\\texit_Sg = y[0] * (1 / time_active) * t \\n\\t\\texit_Pg = y[1] * (1 / time_active) * t\\n\\t\\texit_PPg = y[2] * (1 / time_active) * t\\n\\t\\texit_Sh = y[3] * (1 / time_active) * t\\n\\t\\texit_Ph = y[4] * (1 / time_active) * t\\n\\t\\texit_PPh = y[5] * (1 / time_active) * t\\n\\t\\t#episodic flows\\n\\t\\tSg_to_h = y[0] * (1 / tin_g) * t\\n\\t\\tPg_to_h = y[1] * (1 / tin_g) * t\\n\\t\\tPPg_to_h = y[2] * (1 / tin_g) * t\\n\\t\\tSh_to_g = y[3] * (1 / tin_h) * t\\n\\t\\tPh_to_g = y[4] * (1 / tin_h) * t\\n\\t\\tPPh_to_g = y[5] * (1 / tin_h) * t\\n\\t\\t#entry flows\\n\\t\\tinto_g = new_g * t\\n\\t\\tinto_h = new_h * t\\n\\t\\t#infection flows\\n\\t\\tnewinf_gg = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgg * t\\n\\t\\tnewinf_gh = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgh * t\\n\\t\\tnewinf_h = (y[4] * B1 + y[5] * B2) * Ch * pSh * t\\n\\t\\t#stage progression flows\\n\\t\\tPg_to_PPg = y[1] * D1 * t\\n\\t\\tPPg_to_d = y[2] * D2 * t\\n\\t\\tPh_to_PPh = y[4] * D1 * t\\n\\t\\tPPh_to_d = y[5] * D2 * t\\n\\t\\t\\t\\n\\t\\tstate = [- exit_Sg - newinf_gg - Sg_to_h + into_g + Sh_to_g,\\n\\t\\t\\t\\t - exit_Pg - Pg_to_PPg - Pg_to_h + newinf_gg + Ph_to_g,\\n\\t\\t\\t\\t - exit_PPg - PPg_to_d - PPg_to_h + Pg_to_PPg + PPh_to_g,\\n\\t\\t\\t\\t - exit_Sh - newinf_gh - newinf_h - Sh_to_g + into_h + Sg_to_h,\\n\\t\\t\\t\\t - exit_Ph - Ph_to_PPh - Ph_to_g + newinf_gh + newinf_h + Pg_to_h,\\n\\t\\t\\t\\t - exit_PPh - PPh_to_d - PPh_to_g + Ph_to_PPh + PPg_to_h]\\n\\t\\n\\t\\treturn state\",\n \"def pc_work_time_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.doaesprit_sptr_pc_work_time_avg(self)\",\n \"def timefactor(self, period):\\n\\t\\tdays = period.size() * self.daysinunit(period.unit)\\n\\t\\treturn float(days)/self.daysinbase\",\n \"def transit_duration(rstar, logg, per, ecc):\\n # Replace large ecc values with 0.99\\n ecc = np.where(ecc > 0.99, 0.99, ecc)\\n # Convert logg and rstar into stellar mass\\n mstar = mstar_from_stellarprops(rstar, logg)\\n # Semi-major axis in AU\\n semia = mstar**(1.0/3.0) * (per/365.25)**(2.0/3.0)\\n # transit duration e=0 including pi/4 effect of cos(inc) dist\\n r_sun = 6.9598e10 # cm\\n au2cm = 1.49598e13 # 1 AU = 1.49598e13 cm\\n durat = (per*24.0) / 4.0 * (rstar*r_sun) / (semia*au2cm)\\n #transit duration e > 0\\n durat = durat * np.sqrt(1.0-ecc**2);\\n\\n return durat\",\n \"def sectoFracYear(stime):\\n\\n ltime = convertCtimeToYdate(stime)\\n atemp = re.split(':', ltime)\\n year= int(atemp[0])\\n ydate = int(atemp[1])\\n hours = int(atemp[2])\\n minutes = int(atemp[3])\\n seconds = int(atemp[4])\\n \\n chk = 4.0 * int(0.25 * year)\\n if chk == year:\\n base = 366\\n else:\\n base = 365\\n \\n day = ydate + hours / 24.0 + minutes / 1440.0 + seconds / 86400.0\\n \\n return year + day / base\",\n \"def ctime(self): # real signature unknown; restored from __doc__\\r\\n pass\",\n \"def diff_op(self, args: List[float], time: float) -> List[float]:\\n v, nK, ca = args\\n ca_args: List[float] = [v, ca]\\n dvdt: float = self.dvdt(args=args)\\n dnKdt: float = self.kvhh.dndt(v=v, n=nK)\\n dCadt: float = self.dCadt(args=ca_args)\\n return [dvdt, dnKdt, dCadt]\",\n \"def _calculate_runtime(self):\\n lines = self.file_dic['output'].splitlines()\\n start_time = datetime.strptime(lines[0].strip(), self.timestring_format)\\n fin_time = datetime.strptime(lines[-1].strip(), self.timestring_format)\\n dif = fin_time - start_time\\n self.date = fin_time.strftime('%d %b %Y')\\n self.runtime = dif.total_seconds()\",\n \"def total_seconds(td):\\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6\",\n \"def _normalizeDeltaTime(self, dt : float) -> float:\\n return dt / self.tau\",\n \"def compute_dsc(self, original, shrinked):\\n for i in range(len(original)):\\n x, y = original[i]\\n orig = y-x\\n\\n a, b = shrinked[i]\\n new = b-a\\n\\n dsc = float(new/orig)\\n\\n return dsc\",\n \"def calc_time(self, distance):\\r\\n if distance < 400:\\r\\n return 2*math.sqrt(distance / 1406.25)\\r\\n else:\\r\\n distance -= 400\\r\\n return distance / 750 + 16 / 15\",\n \"def test_day_percentage_timedelta(self):\\n delta = timedelta(seconds=987654, microseconds=321)\\n day_percentage = utils.day_percentage(delta)\\n self.assertEqual(day_percentage, 11.431180559270834)\",\n \"def arithmetic_ret(self) -> float:\\n return float(np.log(self.tsdf).diff().mean() * self.periods_in_a_year)\",\n \"def normalize_times(time,dtstart,dtend):\\n time=np.datetime64(time)\\n dtstart=np.datetime64(dtstart)\\n dtend=np.datetime64(dtend)\\n time_range = (dtend - dtstart).astype('float64')\\n seconds_from_t0 = (time - dtstart).astype('float64')\\n return seconds_from_t0 / time_range\",\n \"def sct_numericdate(cls, d):\\n return (d-cls.SCT_EPOCH).total_seconds() / 60\",\n \"def dCadt(self, args: List[float]) -> float:\\n v, ca = args\\n a_Ca: float = self.params.a_ca\\n area: float = self.params.area\\n tau_Ca: float = self.tau_ca\\n dCadt: float = -a_Ca * (10.0*area*self.cav.i(v)) - ca/tau_Ca\\n return dCadt\",\n \"def seconds_elapsed(date1, date2):\\n return (date1 - date2).total_seconds()\",\n \"def calc_dtdc_star(tpbpc0, spec):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n # Create array of times per bandpass\\n dtpb = np.hstack(tpbpc0)\\n\\n Nbs = len(dtpb)\\n dcomp = np.zeros(Nbs) # completeness\\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def calc_a(dert__):\\n return dert__[[2, 3]] / dert__[1] # np.array([dy, dx]) / g\",\n \"def time_division(annuli):\\n \\n time_div=np.empty(len(annuli),dtype=int)\\n for annulus in range(len(annuli)):\\n r = annuli[annulus]\\n time_div[annulus]=int(viscous_timescale(r) * sample_ratio)\\n return time_div\",\n \"def calc_total_course_duration(timestamps):\\n answer = timedelta()\\n \\n for times in timestamps:\\n m, s = times.split(':')\\n answer += timedelta(minutes=int(m), seconds=int(s))\\n \\n return datetime.strptime(str(answer), '%H:%M:%S').strftime('%H:%M:%S')\\n pass\",\n \"def get_elapsed_time(start, end):\\n return \\\"%s days, %s hours, %s minutes, %s seconds\\\" % dhms_from_seconds(date_diff_in_seconds(start, end))\",\n \"def test_cdf_vs_dt_cy():\\n burstsph, _ = load_burstsph()\\n ns = 1.0\\n nm = 1.0\\n δt = 1e-2 * ns\\n R0 = 6 * nm\\n R_mean = 6.5 * nm\\n R_sigma = 1 * nm\\n τ_relax = 0.2 * ns\\n τ_D = 4. * ns\\n k_D = 1. / τ_D\\n D_fract = np.atleast_1d(1.)\\n ts = burstsph.timestamp.values[:100000]\\n rg = RandomGenerator(Xoroshiro128(1))\\n R_ph, T_ph = depi_cy.sim_DA_from_timestamps2_p_cy(\\n ts, δt, k_D, R0, R_mean, R_sigma, τ_relax, rg, ndt=0, alpha=np.inf)\\n rg = RandomGenerator(Xoroshiro128(1))\\n R_php, T_php = depi_cy.sim_DA_from_timestamps2_p2_cy(\\n ts, δt, np.atleast_1d(k_D), D_fract, R0, R_mean, R_sigma, τ_relax, rg=rg,\\n ndt=0, alpha=np.inf)\\n assert not all([not np.allclose(R_ph, R_php),\\n not np.allclose(T_ph, T_php)])\",\n \"def mdct(x, odd=True):\\n return numpy.real(cmdct(x, odd=odd)) * numpy.sqrt(2)\",\n \"def total_time(self):\\n obs_times = self.clean_obs_times()\\n return _np.sum(obs_times[:, 1] - obs_times[:, 0])\",\n \"def trip_duration_stats(df):\\n\\n print('\\\\nCalculating Trip Duration...\\\\n')\\n start_time = time.time()\\n\\n # TO DO: display total travel time\\n\\n total_travel_time_in_sec = df['Trip Duration'].sum()\\n total_travel_time_in_years = total_travel_time_in_sec // (60 * 60 * 24 *365)\\n\\n modulus1_in_sec = total_travel_time_in_sec - total_travel_time_in_years*(60 * 60 * 24 *365)\\n #print(\\\"modulus1_in_sec:\\\", modulus1_in_sec)\\n total_travel_time_in_months = modulus1_in_sec // (60 * 60 * 24 *31)\\n\\n modulus2_in_sec = modulus1_in_sec - total_travel_time_in_months*(60 * 60 * 24 *31)\\n #print(\\\"modulus2_in_sec:\\\", modulus2_in_sec)\\n total_travel_time_in_weeks = modulus2_in_sec // (60 * 60 * 24 *7)\\n\\n modulus3_in_sec = modulus2_in_sec - total_travel_time_in_weeks*(60 * 60 * 24 *7)\\n #print(\\\"modulus3_in_sec:\\\", modulus3_in_sec)\\n total_travel_time_in_days = modulus3_in_sec // (60 * 60 * 24)\\n\\n modulus4_in_sec = modulus3_in_sec - total_travel_time_in_days*(60 * 60 * 24)\\n #print(\\\"modulus4_in_sec:\\\", modulus4_in_sec)\\n total_travel_time_in_hours = modulus4_in_sec // (60 * 60)\\n\\n modulus5_in_sec = modulus4_in_sec - total_travel_time_in_hours*(60 * 60)\\n #print(\\\"modulus5_in_sec:\\\", modulus5_in_sec)\\n total_travel_time_in_minutes = modulus5_in_sec // 60\\n\\n modulus6_in_sec = modulus5_in_sec - total_travel_time_in_minutes*60\\n #print(\\\"modulus6_in_sec:\\\", modulus6_in_sec)\\n total_travel_time_in_seconds_modulus = modulus6_in_sec\\n\\n print(\\\"total travel time of all Users combined:\\\\n YEARS: {} \\\\n MONTHS: {} \\\\n WEEKS: {} \\\\n DAYS: {} \\\\n HOURS: {} \\\\n MINUTES: {} \\\\n SECONDS: {} \\\\n\\\".format(total_travel_time_in_years, total_travel_time_in_months, total_travel_time_in_weeks, total_travel_time_in_days, total_travel_time_in_hours, total_travel_time_in_minutes, total_travel_time_in_seconds_modulus))\\n\\n # TO DO: display mean travel time\\n\\n mean_travel_time_in_sec = df['Trip Duration'].mean()\\n mean_travel_time_in_minutes = mean_travel_time_in_sec // 60\\n modulus_in_sec = mean_travel_time_in_sec - mean_travel_time_in_minutes*60\\n mean_travel_time_in_seconds_modulus = modulus_in_sec\\n\\n print(\\\"mean travel time:\\\\n MINUTES: {} \\\\n SECONDS: {} \\\\n\\\".format(int(mean_travel_time_in_minutes), mean_travel_time_in_seconds_modulus))\\n\\n#trip_duration_stats(pd.read_csv('{}.csv'.format(city)))\\n\\n print(\\\"\\\\nThis took %s seconds.\\\" % (time.time() - start_time))\\n print('-'*40)\",\n \"def discharge_date_time(subject_id, conn):\\n cur = conn.cursor()\\n sql = \\\"\\\"\\\"SELECT ED_DEPARTURE_TIME, EDDisposition FROM DEMOGRAPHICS\\n WHERE STUDYID = {}\\\"\\\"\\\".format(subject_id)\\n cur.execute(sql)\\n data = cur.fetchall()\\n if data[0][0]: # subjects who were discharged from the ED\\n date, time = data[0][0].split(\\\" \\\")\\n dispo = data[0][1]\\n return date, time, 'discharge', dispo\\n else: # Subjects who were admitted\\n sql = \\\"\\\"\\\"SELECT HOSP_ADMSN_TIME, EDDisposition FROM DEMOGRAPHICS\\n WHERE STUDYID = {}\\\"\\\"\\\".format(subject_id)\\n cur.execute(sql)\\n data = cur.fetchall()\\n if data[0][0]:\\n date, time = data[0][0].split(\\\" \\\")\\n dispo = data[0][1]\\n return date, time, 'discharge', dispo\",\n \"def t_conv_func(t_end,t_start,input_type='datetime',output_units='hours'):\\n if input_type == \\\"datetime\\\":\\n diff = (t_end-t_start).total_seconds ()\\n elif input_type == \\\"seconds\\\":\\n diff = t_end-t_start\\n else:\\n raise NotImplementedError\\n\\n if output_units == 'seconds':\\n return diff\\n elif output_units == 'minutes':\\n return diff/60.0\\n elif output_units == 'hours':\\n return diff/3600.0\\n else:\\n raise NotImplementedError\",\n \"def pc_work_time_avg(self):\\n return _spacegrant_swig.hdlc_deframer_sptr_pc_work_time_avg(self)\",\n \"def d_dt(self, r, t):\\n return self.d_do(r,t) * do_dt(r,t)\",\n \"def discretize(self,dt):\\n res = self.discretize_state(dt)\\n n = len(res.milestones[0])//2\\n return Trajectory(res.times,[m[:n] for m in res.milestones])\",\n \"def get_dt_per_index(self):\\n dt = self.data[1,-1] - self.data[0,-1]\\n return dt\",\n \"def dd2sec(dd):\\n minute, second = divmod(abs(dd) * 3600, 60)\\n degree, minute = divmod(minute, 60)\\n sec = (degree * 3600) + (minute * 60) + second\\n return sec if dd >= 0 else -sec\",\n \"def get_duration(self):\\n return float(self.time.iloc[-1] - self.time.iloc[0])\",\n \"def __call__(self):\\n \\n if self.funciona:\\n t = self.timeFunc() - self.t0 - self.retraso\\n elif self.t0!=None:\\n t = self.parada - self.t0 - self.retraso\\n else:\\n t = None\\n return t\",\n \"def calculer_energie_cinetique_tnt(energie_cinetique):\\n return energie_cinetique / 4184\",\n \"def period(self) -> int:\",\n \"def _steps_to_seconds(steps, qpm):\\n return steps * 60.0 / qpm / get_steps_per_quarter()\",\n \"def advantage(cpu_dt, gpu_dt):\\n assert gpu_dt >= 0 and cpu_dt >= 0\\n if gpu_dt == 0 and cpu_dt == 0:\\n return numpy.nan\\n elif gpu_dt == 0:\\n return numpy.inf\\n else:\\n return cpu_dt / gpu_dt\",\n \"def advantage(cpu_dt, gpu_dt):\\r\\n assert gpu_dt >= 0 and cpu_dt >= 0\\r\\n if gpu_dt == 0 and cpu_dt == 0:\\r\\n return numpy.nan\\r\\n elif gpu_dt == 0:\\r\\n return numpy.inf\\r\\n else:\\r\\n return cpu_dt / gpu_dt\",\n \"def REAL_TIME_ADVANCE(dt):\",\n \"def get_dtc(self):\\n r = self.sensor(1)\\n num = r[0]\\n # get all DTC, 3 per mesg response\\n self.send_command(GET_DTC_COMMAND)\\n #for i in range(0, ceil(num/3.0)):\\n res = self.get_result()\\n print res\\n return res\\n # fixme: finish\",\n \"def _STEPS2TIME(step):\\n return step/1000.\",\n \"def dspmt(t):\\n t = np.asarray(t)\\n return spmt(t) - spmt(t - 1)\",\n \"def test_curriculum_progress(self):\\n student_id = '0104926787'\\n career_id = 44\\n curriculum_id = 1\\n career_plan = 4\\n expected_result = self._get_curriculum_progress()\\n actual_result = self.ucuenca.curriculum_progress(\\n student_id, career_id, curriculum_id, career_plan\\n )\\n self.assertEqual(actual_result, expected_result)\",\n \"def pc_work_time_total(self):\\n return _TestA_swig.cleanslate_sptr_pc_work_time_total(self)\",\n \"def ddm(self):\\n if self.positive:\\n return DDMAngle(self.degree, self.minute + (self.second/60))\\n else:\\n return -DDMAngle(self.degree, self.minute + (self.second/60))\",\n \"def dvdt(self, args: List[float]) -> float:\\n v, h_nav, n_kvhh, h_kva, m_kvsi, s_ampar, _, s_nmdar, s_gabar, ca = args\\n return ((-10.0*self.params.area \\n * (self.leak.i(v)\\n + self.nav.i(v, h=h_nav) \\n + self.kvhh.i(v, n=n_kvhh)\\n + self.kva.i(v, h=h_kva)\\n + self.kvsi.i(v, m=m_kvsi)\\n + self.cav.i(v)\\n + self.kca.i(v, ca=ca)\\n + self.nap.i(v)\\n + self.kir.i(v))\\n - (self.ampar.i(v, s=s_ampar)\\n + self.nmdar.i(v, s=s_nmdar)\\n + self.gabar.i(v, s=s_gabar))) \\n / (10.0*self.params.cm*self.params.area))\",\n \"def tt_ut1(self):\\n # return the delta time for the input date converted to days\\n return interpolate_delta_time(_delta_file, self.tide)\",\n \"def pc_work_time_avg(self) -> \\\"float\\\":\\n return _beamforming_swig.phasedarray_sptr_pc_work_time_avg(self)\",\n \"def trip_duration_stats(df, city):\\r\\n\\r\\n print(\\\"\\\\n\\\" * 2 + '*' * 20)\\r\\n print('Calculating Trip Duration...\\\\n')\\r\\n start_time = time.time()\\r\\n \\r\\n # TO DO: display total travel time\\r\\n try:\\r\\n df['Time Delta'] = df['End Time'] - df['Start Time']\\r\\n total_time_delta = df['Time Delta'].sum()\\r\\n print('The total travel time :', total_time_delta)\\r\\n except Exeption as e:\\r\\n print('An exception has been occurred while displaying total travel time: {}'.format(e))\\r\\n \\r\\n # TO DO: display mean travel time\\r\\n try:\\r\\n total_mean = df['Time Delta'].mean()\\r\\n print('The mean travel time :', total_mean)\\r\\n except Exception as e:\\r\\n print('An exception has been occurred while displaying mean travel time: {}'.format(e))\\r\\n \\r\\n print(\\\"\\\\nThis took %s seconds.\\\" % (time.time() - start_time))\\r\\n print('*' * 20)\",\n \"def get_frac_secs(self):\\n return _uhd_swig.time_spec_t_get_frac_secs(self)\",\n \"def suspected_per_hour(self):\\r\\n return (3600.*(self.circ_suspected+self.strm_suspected\\r\\n +self.circ_failed+self.strm_failed))/self.current_uptime()\",\n \"def _compute_duration(self):\\n diff_float = 0\\n for ts_line in self:\\n if ts_line.x_start_date:\\n st_datetime = fields.Datetime.from_string(\\n ts_line.x_start_date)\\n # autocomplete date from start date\\n st_date_tz = fields.Datetime.context_timestamp(\\n self, st_datetime).date()\\n ts_line.date = st_date_tz\\n\\n # autocomplete name from start date\\n st_datetime_tz = fields.Datetime.context_timestamp(\\n self, st_datetime)\\n string_st_dt_tz = fields.Datetime.to_string(st_datetime_tz)\\n ts_line.name = ts_line.user_id.name + '/' + string_st_dt_tz\\n\\n en_datetime = fields.Datetime.from_string(\\n ts_line.x_end_date)\\n diff = en_datetime - st_datetime\\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\\n # del 1 hour for breaking lunch\\n diff_float = round(diff.total_seconds() / 3600.0, 2)-1\\n else:\\n diff_float = round(diff.total_seconds() / 3600.0, 2)\\n ts_line.unit_amount = diff_float\",\n \"def getDuration(self):\\n #return np.sum(self.subintinfo['TSUBINT']) #This is constant.\\n return np.sum(self.getSubintinfo('TSUBINT')) #This is constant.\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59870166","0.58656496","0.57553","0.57553","0.55991685","0.5563111","0.5560583","0.5544466","0.55035794","0.54969424","0.54954","0.54544187","0.54526633","0.5389543","0.5374481","0.53677905","0.535153","0.5330187","0.53280985","0.5323999","0.53121424","0.5307881","0.5301316","0.529198","0.5275388","0.5270861","0.52647144","0.5243139","0.521929","0.52159023","0.5203909","0.5200913","0.51909167","0.51844877","0.51696265","0.51634693","0.5162594","0.5160375","0.51582426","0.5144686","0.5141396","0.5133268","0.5130017","0.5129579","0.5127712","0.51261044","0.5123514","0.5119815","0.51190925","0.5113447","0.5111034","0.5108575","0.510814","0.51027703","0.50978667","0.5091917","0.5082404","0.5075369","0.50701326","0.50688004","0.5067052","0.505107","0.50468534","0.5037492","0.5034837","0.5030552","0.5030448","0.50276697","0.5027231","0.50250757","0.5009831","0.50041604","0.500337","0.49979448","0.49953634","0.49949917","0.49927625","0.49912","0.49893212","0.49843416","0.49800473","0.49791092","0.4976052","0.49755633","0.49710882","0.49670815","0.49639887","0.49623406","0.4961864","0.49597508","0.4956644","0.49560755","0.49531767","0.4951627","0.49466085","0.4946317","0.49444923","0.49420878","0.49417895","0.4939341","0.49370268"],"string":"[\n \"0.59870166\",\n \"0.58656496\",\n \"0.57553\",\n \"0.57553\",\n \"0.55991685\",\n \"0.5563111\",\n \"0.5560583\",\n \"0.5544466\",\n \"0.55035794\",\n \"0.54969424\",\n \"0.54954\",\n \"0.54544187\",\n \"0.54526633\",\n \"0.5389543\",\n \"0.5374481\",\n \"0.53677905\",\n \"0.535153\",\n \"0.5330187\",\n \"0.53280985\",\n \"0.5323999\",\n \"0.53121424\",\n \"0.5307881\",\n \"0.5301316\",\n \"0.529198\",\n \"0.5275388\",\n \"0.5270861\",\n \"0.52647144\",\n \"0.5243139\",\n \"0.521929\",\n \"0.52159023\",\n \"0.5203909\",\n \"0.5200913\",\n \"0.51909167\",\n \"0.51844877\",\n \"0.51696265\",\n \"0.51634693\",\n \"0.5162594\",\n \"0.5160375\",\n \"0.51582426\",\n \"0.5144686\",\n \"0.5141396\",\n \"0.5133268\",\n \"0.5130017\",\n \"0.5129579\",\n \"0.5127712\",\n \"0.51261044\",\n \"0.5123514\",\n \"0.5119815\",\n \"0.51190925\",\n \"0.5113447\",\n \"0.5111034\",\n \"0.5108575\",\n \"0.510814\",\n \"0.51027703\",\n \"0.50978667\",\n \"0.5091917\",\n \"0.5082404\",\n \"0.5075369\",\n \"0.50701326\",\n \"0.50688004\",\n \"0.5067052\",\n \"0.505107\",\n \"0.50468534\",\n \"0.5037492\",\n \"0.5034837\",\n \"0.5030552\",\n \"0.5030448\",\n \"0.50276697\",\n \"0.5027231\",\n \"0.50250757\",\n \"0.5009831\",\n \"0.50041604\",\n \"0.500337\",\n \"0.49979448\",\n \"0.49953634\",\n \"0.49949917\",\n \"0.49927625\",\n \"0.49912\",\n \"0.49893212\",\n \"0.49843416\",\n \"0.49800473\",\n \"0.49791092\",\n \"0.4976052\",\n \"0.49755633\",\n \"0.49710882\",\n \"0.49670815\",\n \"0.49639887\",\n \"0.49623406\",\n \"0.4961864\",\n \"0.49597508\",\n \"0.4956644\",\n \"0.49560755\",\n \"0.49531767\",\n \"0.4951627\",\n \"0.49466085\",\n \"0.4946317\",\n \"0.49444923\",\n \"0.49420878\",\n \"0.49417895\",\n \"0.4939341\",\n \"0.49370268\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12886,"cells":{"query":{"kind":"string","value":"get all the data, design plus raw plus normalized for subexperiment"},"document":{"kind":"string","value":"def data(self):\n return pandas.concat([i.data for i in list(self.plates.values())])"},"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 datasets(self):\n pass","def getData(trainSize):\r\n return splitData([getReal(), getFake()], trainSize=trainSize)","def get_raw(data_folder, dataset_id, subject, stim_type=\"distress\"):\r\n\r\n if dataset_id in [\"raw_clean_32\"]: #two conditions experiments\r\n raw_0, raw_1, events0, events1 = get_dataset_low_v_high(data_folder, dataset_id, subject, ShowFig=False)\r\n elif dataset_id in [\"Distress2010\",\"NormativeDB\",\"Tinnitus_EEG\"]:\r\n raw_0, raw_1, events0, events1 = get_dataset_distress(data_folder, dataset_id,\r\n subject, stim_type=stim_type, ShowFig=False)\r\n else:\r\n print(dataset_id + \": Unknown dataset, please check compatible dataset using get_dataset_list().\")\r\n print(dataset_id + \": if you want, you can add this dataset to get_dataset_list() and get_raw(),\")\r\n print(dataset_id + \": OR you can use directly load_sessions_raw() if your data respect a known structure.\")\r\n\r\n return raw_0, raw_1, events0, events1","def _extract_data(self) -> np.ndarray:\n \n mats = Material.objects.all()\n \n mat_arrays = []\n for mat in mats: # django queryset -> python list\n mat_features = []\n \n # Add data\n # Some data are missing here.\n #TODO: Delete those if sentences after cleaning the data.\n mat_features.append(mat.model_surface_temperature if mat.model_surface_temperature!=None else 0)\n mat_features.append(mat.melt_temperature if mat.melt_temperature!=None else 0)\n mat_features.append(mat.mold_temperature_range_min if mat.mold_temperature_range_min!=None else 0)\n mat_features.append(mat.mold_temperature_range_max if mat.mold_temperature_range_max!=None else 0)\n mat_features.append(mat.melt_temperature_range_min if mat.melt_temperature_range_min!=None else 0)\n mat_features.append(mat.melt_temperature_range_max if mat.melt_temperature_range_max!=None else 0)\n mat_features.append(mat.absolute_maximum_melt_temperature if mat.absolute_maximum_melt_temperature!=None else 0)\n mat_features.append(mat.ejection_temperature if mat.ejection_temperature!=None else 0)\n mat_features.append(mat.maximum_shear_stress if mat.maximum_shear_stress!=None else 0)\n mat_features.append(mat.maximum_shear_rate if mat.maximum_shear_rate!=None else 0)\n mat_features.append(mat.melt_density if mat.melt_density!=None else 0)\n mat_features.append(mat.solid_density if mat.solid_density!=None else 0)\n mat_features.append(mat.pvt_b5 if mat.pvt_b5!=None else 0)\n mat_features.append(mat.pvt_b6 if mat.pvt_b6!=None else 0)\n mat_features.append(mat.pvt_b1m if mat.pvt_b1m!=None else 0)\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\n mat_features.append(mat.pvt_b4m if mat.pvt_b4m!=None else 0)\n mat_features.append(mat.pvt_b1s if mat.pvt_b1s!=None else 0)\n mat_features.append(mat.pvt_b2s if mat.pvt_b2s!=None else 0)\n mat_features.append(mat.pvt_b3s if mat.pvt_b3s!=None else 0)\n mat_features.append(mat.pvt_b4s if mat.pvt_b4s!=None else 0)\n mat_features.append(mat.pvt_b7 if mat.pvt_b7!=None else 0)\n mat_features.append(mat.pvt_b8 if mat.pvt_b8!=None else 0)\n mat_features.append(mat.pvt_b9 if mat.pvt_b9!=None else 0)\n mat_features.append(mat.elastic_modulus_e1 if mat.elastic_modulus_e1!=None else 0)\n mat_features.append(mat.elastic_modulus_e2 if mat.elastic_modulus_e2!=None else 0)\n mat_features.append(mat.poisson_ratio_v12 if mat.poisson_ratio_v12!=None else 0)\n mat_features.append(mat.poisson_ratio_v23 if mat.poisson_ratio_v23!=None else 0)\n mat_features.append(mat.shear_modulus_g12 if mat.shear_modulus_g12!=None else 0.)\n mat_features.append(mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha1 if mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha1!=None else 0.)\n mat_features.append(mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha2 if mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha2!=None else 0.)\n mat_features.append(mat.seven_params_n if mat.seven_params_n!=None else 0.)\n mat_features.append(mat.seven_params_Tau if mat.seven_params_Tau!=None else 0.)\n mat_features.append(mat.seven_params_D1 if mat.seven_params_D1!=None else 0.)\n mat_features.append(mat.seven_params_D2 if mat.seven_params_D2!=None else 0.)\n mat_features.append(mat.seven_params_D3 if mat.seven_params_D3!=None else 0.)\n mat_features.append(mat.seven_params_A1 if mat.seven_params_A1!=None else 0.)\n mat_features.append(mat.seven_params_A2 if mat.seven_params_A2!=None else 0.)\n mat_features.append(mat.c1 if mat.c1!=None else 0.)\n mat_features.append(mat.c2 if mat.c2!=None else 0.)\n mat_features.append(mat.conversion_temperature if mat.conversion_temperature!=None else 0.)\n mat_features.append(mat.MFR_temperature if mat.MFR_temperature!=None else 0.)\n mat_features.append(mat.MFR_loading if mat.MFR_loading!=None else 0.)\n mat_features.append(mat.measured_MFR if mat.measured_MFR!=None else 0.)\n \n mat_arrays.append(mat_features)\n \n # Get numpy arrays.\n mat_arrays = np.array(mat_arrays, dtype=np.float64)\n \n return mat_arrays","def get_main_dataset(self) -> pd.DataFrame:\n pass","def extract_data(self):\n values = {}\n for injkey in self.data_sets.keys():\n values[injkey] = {}\n alldata = self.data_sets[injkey]\n paramkeys = alldata['params'].keys()\n for datakey in alldata.keys():\n if not datakey == 'params':\n values[injkey][datakey] = {}\n values[injkey][datakey]['metric_val'] = {}\n values[injkey][datakey]['metric_val']['vals'] = []\n for paramkey in paramkeys:\n values[injkey][datakey][paramkey] = {}\n values[injkey][datakey][paramkey]['vals'] = []\n trials = alldata[datakey]\n for trial_num in trials.keys():\n trial = trials[trial_num]\n values[injkey][datakey]['metric_val']['vals'] \\\n .append(trial['metric_val'])\n values[injkey][datakey]['metric_val']['type'] \\\n = trial['metric']\n values[injkey][datakey]['metric_val']['units'] \\\n = 'dimensionless'\n param_vals = trial['params']\n for param_name in param_vals.keys():\n val, units = self.parse_pint_string(\n pint_string=param_vals[param_name]\n )\n values[injkey][datakey][param_name]['vals'] \\\n .append(float(val))\n values[injkey][datakey][param_name]['units'] \\\n = units\n self.values = values","def data_details(self):\n\t\t# Obtain the full Drusen files\n\t\tdata_files = glob(op.join(self.data_dir, '*'))\n\n\t\t# Obtain the data ID and total images\n\t\tdata_id = [single_file.split('\\\\')[-1].split('-')[1] for single_file in data_files]\n\t\tself.total_imgs = len(data_id)\n\t\tself.data_id = np.unique(data_id)\n\t\treturn self","def build_data(self):\n from desiutil.io import combine_dicts\n # Loop on exposures\n odict = {}\n for qanight in self.qa_nights:\n for qaexp in qanight.qa_exps:\n # Get the exposure dict\n idict = write_qa_exposure('foo', qaexp, ret_dict=True)\n odict = combine_dicts(odict, idict)\n # Finish\n self.data = odict","def _extract_imp_data(self) -> np.ndarray:\n \n mats = Material.objects.all()\n \n mat_arrays = []\n for mat in mats: # django queryset -> python list\n mat_features = []\n \n # Add data\n # Some data are missing here.\n #TODO: Delete those if sentences after cleaning the data.\n mat_features.append(mat.pvt_b5 if mat.pvt_b5!=None else 0)\n mat_features.append(mat.pvt_b6 if mat.pvt_b6!=None else 0)\n mat_features.append(mat.pvt_b1m if mat.pvt_b1m!=None else 0)\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\n mat_features.append(mat.pvt_b4m if mat.pvt_b4m!=None else 0)\n mat_features.append(mat.pvt_b1s if mat.pvt_b1s!=None else 0)\n mat_features.append(mat.pvt_b2s if mat.pvt_b2s!=None else 0)\n mat_features.append(mat.pvt_b3s if mat.pvt_b3s!=None else 0)\n mat_features.append(mat.pvt_b4s if mat.pvt_b4s!=None else 0)\n mat_features.append(mat.pvt_b7 if mat.pvt_b7!=None else 0)\n mat_features.append(mat.pvt_b8 if mat.pvt_b8!=None else 0)\n mat_features.append(mat.pvt_b9 if mat.pvt_b9!=None else 0)\n mat_features.append(mat.seven_params_n if mat.seven_params_n!=None else 0.)\n mat_features.append(mat.seven_params_Tau if mat.seven_params_Tau!=None else 0.)\n mat_features.append(mat.seven_params_D1 if mat.seven_params_D1!=None else 0.)\n mat_features.append(mat.seven_params_D2 if mat.seven_params_D2!=None else 0.)\n mat_features.append(mat.seven_params_D3 if mat.seven_params_D3!=None else 0.)\n mat_features.append(mat.seven_params_A1 if mat.seven_params_A1!=None else 0.)\n mat_features.append(mat.seven_params_A2 if mat.seven_params_A2!=None else 0.)\n \n mat_arrays.append(mat_features)\n \n # Get numpy arrays.\n mat_arrays = np.array(mat_arrays, dtype=np.float64)\n \n return mat_arrays","def get_data(self):\n if self.random_seeds: \n self._validate_random_seeds()\n seed_iter = list(map(iter,self.random_seeds))\n nsamples = len(self.random_seeds[0])\n else:\n seed_iter = None\n nsamples = self.numsamples\n self._set_meta_features()\n for _ in tqdm(range(nsamples)):\n self._update_meta_features(seed_iter)\n self._sample()\n yield self._extract_features()","def collect_experiment_data(self, dedupe=False):\n data = {}\n\n for exp in self.experiments.values():\n expdir = os.path.join(self.datadir, exp.name)\n goals = sorted(\n [goal\n for goal, experiments in self.experiments_by_goal.items()\n if exp in experiments])\n data[exp.name] = {'goals': goals, 'variants': {}}\n\n for variant in exp.variants:\n path = partial(os.path.join, expdir, variant)\n if dedupe:\n trial_identities = get_identities(path('__all__'))\n trialc = len(trial_identities)\n else:\n trialc = count_entries(path('__all__'), dedupe=False)\n data[exp.name]['variants'][variant] = vdata = {'trials': trialc, 'goals': {}}\n\n for goal in goals:\n vdata['goals'][goal] = goaldata = {}\n if dedupe:\n conv_identities = trial_identities.intersection(\n get_identities(path(goal)))\n convc = len(conv_identities)\n else:\n convc = count_entries(path(goal), dedupe=False)\n goaldata['conversions'] = convc\n goaldata['rate'] = (float(convc) / trialc\n if trialc\n else float('nan'))\n return data","def _get_data(self):\n project_name, experiment_id = self.parent._get_parent_identifiers()\n\n self._data = self.repository.get_dataframe_data(\n project_name, self.id, experiment_id=experiment_id\n )","def load_own_data():\n data = Data()\n features = data.read_selected_features()\n dataframe = data.get_dataframe_with(features)\n return normalize(dataframe.values)","def get_data_and_model_samples(self):\n model_samples = (\n self.net_.sample_fantasy(\n x=self.model_samples_[-1],\n num_mc_steps=self.num_sample_mc_steps,\n beta=self.sample_beta,\n mc_dynamics=self.sampler,\n )\n .detach()\n .cpu()\n .numpy()\n )\n data_sample_ixs = torch.randint(\n 0, self.samples.shape[0], size=(model_samples.shape[0],)\n )\n data_samples = self.samples[data_sample_ixs, ...]\n return data_samples, model_samples","def collect_datset(self):\n response = requests.get(self.url)\n lines = response.text.splitlines()\n data = []\n for item in lines:\n item = item.split(\",\")\n data.append(item)\n data.pop(0) # to remove labels from list\n dataset = np.matrix(data)\n return dataset","def build_data_set(self):\n if not self.assert_data_correct():\n self.download_all_data()\n self.unpack_rename_data()\n self.split_data_characters()\n self.clean_data_fragments()\n self.create_font_data()\n if not self.assert_train_augmented():\n self.augment_train_data()\n if not self.assert_style_data_correct():\n self.download_style_data()\n self.unpack_rename_data()","def get_data(self): \n self.improvement = []\n self.corrsq = []\n for filename in onlyfiles:\n mst = MST(filename, mypath=mypath)\n mst.estimate_correct_seqences()\n mst.estimate_improvement()\n self.mst.append(mst)\n\n self.corrsq.append(mst.corrsq)\n self.improvement.append(mst.improvement)\n\n\n\n print(f\"cor = {improvement}\")\n print(f\"improvement = {improvement}\")\n print(f\"mittelwert der improvement = {np.mean(improvement)}\")\n print(f\"Standardabweichung der lersteigung = {np.std(improvement)}\")","def data(self):\n return {\"estimate\":self.get_estimate(),\n \"samplers\":self.samplers}","def datasets(self):\n return [Dataset.GWAS_CATALOG, Dataset.CLINVAR, Dataset.EFO]","def get_data(self):","def get_data():\n wga_df = pd.read_csv(os.path.join(MODEL_DIR, 'wga/sculptures/wga_sculpture_periods.csv'), index_col=0)\n wikiart_df = pd.read_csv(os.path.join(MODEL_DIR, 'wikiart/sculptures/wikiart_sculpture_periods.csv'), index_col=0)\n nga_df = pd.read_csv(os.path.join(MODEL_DIR, 'nga/sculptures/nga_sculpture_periods.csv'), index_col=0)\n\n ######## Fix name for WGA and WikiaRt ###########\n wga_df['Author'] = wga_df.apply(lambda x: fix_name_wga(x['Author']), axis=1)\n wikiart_df['Author'] = wikiart_df.apply(lambda x: fix_name_wiki(x['Author']), axis=1)\n nga_df['Author'] = nga_df.apply(lambda x: fix_name_nga(x['Author']), axis=1)\n\n df = pd.concat([wga_df, wikiart_df, nga_df], ignore_index=True, sort=True)\n\n df['Author_Fixed'] = df.apply(lambda x: fix_text(x['Author']), axis=1)\n df['title_fixed'] = df.apply(lambda x: fix_text(x['title']), axis=1)\n\n periods = [\"BAROQUE\", \"EARLY RENAISSANCE\", \"MEDIEVAL\", \"NEOCLASSICISM\", \"HIGH RENAISSANCE\", \"MINIMALISM\", \"REALISM\",\n \"IMPRESSIONISM\", \"ROCOCO\", \"SURREALISM\", \"MANNERISM\", \"ROMANTICISM\",\n ]\n df['Period'] = df.apply(lambda row: row['Period'].upper(), axis=1)\n\n # Get Desired Periods\n df['Period'] = df.apply(lambda x: \"SURREALISM\" if \"SURREALISM\" in x['Period'] else x['Period'], axis=1)\n df = df[(df['Period'].isin(periods))]\n df = df.sort_values(['Author_Fixed', 'title_fixed'])\n\n #print(\"Combined Drop Rows:\", df.shape[0] - df.drop_duplicates(subset=['Author_Fixed', 'title_fixed']).shape[0])\n\n df = df.drop_duplicates(subset=['Author_Fixed', 'title_fixed'], keep='last')\n\n # Drop Duplicate Sculptures\n df = df[~df['file'].isin(DUP_SCULPTURES)].reset_index(drop=True)\n\n #print(df['Period'].value_counts())\n\n return df","def get_new_modelling_data():\n # get latest epidemic data from OWID \n\n df = pd.read_json(requests.get(\"https://covid.ourworldindata.org/data/owid-covid-data.json\").content)\n data = pd.DataFrame(df[\"POL\"][\"data\"])\n\n # get latest government restriction data from Oxford tracker\n response = requests.get(\"https://raw.githubusercontent.com/OxCGRT/covid-policy-tracker/master/data/OxCGRT_latest.csv\").content\n rest = pd.read_csv(io.StringIO(response.decode('utf-8')))\n rest = rest[rest.CountryName == \"Poland\"]\n\n modelling = pd.DataFrame(Mobility.objects.values())\n prepare_model_data(data,rest,modelling)","def reduce_data(self, ctx):\n self.baselines_type = ctx.get(\"baselines_type\")\n visibilities = ctx.get(\"visibilities\")\n p_signal = self.compute_power(visibilities)\n\n # Remember that the results of \"simulate\" can be used in two places: (i) the computeLikelihood method, and (ii)\n # as data saved to file. In case of the latter, it is useful to save extra variables to the dictionary to be\n # looked at for diagnosis, even though they are not required in computeLikelihood().\n return [dict(p_signal=p_signal, baselines=self.baselines, frequencies=self.frequencies,\n u=self.u, eta=self.eta)]\n #, nbl_uv=self.nbl_uv, nbl_uvnu=self.nbl_uvnu, nbl_u=self.nbl_u, grid_weights=self.grid_weights)]","def getAllData(self):\r\n return self.data","def getMeasures():","def build_data(self):\n return self.mean, self.sigma","def data(dataset=\"bio_eventrelated_100hz\"):\n # TODO: one could further improve this function with like\n # selectors 'ecg=True, eda=True, restingstate=True' that would\n # find the most appropriate dataset\n\n dataset = dataset.lower()\n\n # TODO: change this path back to \"master\"\n path = \"https://raw.githubusercontent.com/neuropsychology/NeuroKit/dev/data/\"\n\n # Signals as vectors =======================\n if dataset in [\"eeg\", \"eeg_150hz\", \"eeg.txt\"]:\n return pd.read_csv(path + \"eeg.txt\").values[:, 0]\n\n if dataset in [\"rsp\", \"rsp_1000hz\", \"rsp_1000hz.txt\"]:\n return pd.read_csv(path + \"rsp_1000hz.txt\", header=None).values[:, 0]\n\n if dataset in [\"ecg\", \"ecg_1000hz\", \"ecg_1000hz.csv\"]:\n return pd.read_csv(path + \"ecg_1000hz.csv\")[\"ECG\"].values\n\n if dataset in [\"ecg_3000hz\", \"ecg_3000hz.csv\"]:\n return pd.read_csv(path + \"ecg_1000hz.csv\")[\"ECG\"].values\n\n if dataset in [\"eog\", \"veog\", \"eog_100hz\", \"eog_100hz.csv\"]:\n return pd.read_csv(path + \"eog_100hz.csv\")[\"vEOG\"].values\n\n # Dataframes ===============================\n if dataset == \"iris\":\n info = sklearn_datasets.load_iris()\n data = pd.DataFrame(\n info.data, columns=[\"Sepal.Length\", \"Sepal.Width\", \"Petal.Length\", \"Petal.Width\"]\n )\n data[\"Species\"] = info.target_names[info.target]\n return data\n\n if dataset in [\"eogs\", \"eogs_200hz\", \"eog_200hz\", \"eog_200hz.csv\"]:\n return pd.read_csv(path + \"eog_200hz.csv\")\n\n # Add extension\n if dataset in [\"bio_resting_8min_200hz\"]:\n dataset += \".json\"\n\n # Specific case for json file\n if dataset.endswith(\".json\"):\n if \"https\" not in dataset:\n data = pd.read_json(path + dataset, orient=\"index\")\n else:\n data = pd.read_json(dataset, orient=\"index\")\n df = {}\n for participant, row in data.iterrows():\n for _, data_string in row.items():\n data_list = json.loads(data_string)\n data_pd = pd.DataFrame(data_list)\n df[participant] = data_pd\n\n return df\n\n # TODO: Add more EEG (fif and edf datasets)\n if dataset in [\"eeg_1min_200hz\"]:\n\n return pickle.load(\n urllib.request.urlopen(\n \"https://github.com/neuropsychology/NeuroKit/blob/dev/data/eeg_1min_200hz.pickle?raw=true\"\n )\n )\n\n # General case\n file, ext = os.path.splitext(dataset) # pylint: disable=unused-variable\n if ext == \"\":\n df = pd.read_csv(path + dataset + \".csv\")\n else:\n if \"https\" not in dataset:\n df = pd.read_csv(path + dataset)\n else:\n df = pd.read_csv(dataset)\n return df","def get_data():\r\n spatial_expmat = np.load('/home/anniegao/spatial_magan/data/spatial_pca_with_coords.npz')['arr_0']\r\n spatial_expmat[:,100:] *= 5\r\n rna_expmat = np.load('/home/anniegao/spatial_magan/data/rna_pca_sampled.npz')['arr_0']\r\n spatial_pca_components = np.load('/home/anniegao/spatial_magan/data/spatial_pca_100components.npz')['arr_0']\r\n rna_pca_components = np.load('/home/anniegao/spatial_magan/data/rna_pca_100components.npz')['arr_0']\r\n spatial_cluster_labels = np.load('/home/anniegao/spatial_magan/data/spatial_cluster_3_labels_phate.npz')['arr_0']\r\n rna_cluster_labels = np.load('/home/anniegao/spatial_magan/data/rna_cluster_5_labels_sampled.npz')['arr_0']\r\n return spatial_expmat, rna_expmat, spatial_pca_components, rna_pca_components, spatial_cluster_labels, rna_cluster_labels","def _get_data(self, species_id, fit_id):\n return self.raw_results[fit_id][species_id]","def getCurentData(self):\n if not self.labExperiment:\n super().getCurentData()\n else:\n return np.array(self.connection.query('get_actuator_data'))","def create_subexperiments(self):\n subexperiments = {}\n for label, df in self.design.groupby(level=0):\n subexperiments[label] = SubExperiment(label, df.loc[label], self.root)\n return subexperiments","def _build_datasets(self):\n self._build_datasets_sis3302()\n self._build_datasets_sis3305()","def data(self):\n # Regenerate the extra data\n if self._req_update_fill:\n self._generate_fill()\n if self._req_update_variation:\n self._generate_variations()\n\n output = self._data_words\n\n # Add variations\n where = np.where(output == '')\n output[where] = self._data_variations[where]\n\n # Add fill\n where = np.where(output == '')\n output[where] = self._data_fill.reshape(self.shape)[where]\n\n return output","def get_data_subsets(t0, t1):\n\n # Iridium data:\n irid = iridium[(iridium.time >= t0) & (iridium.time <= t1)]\n irid_B = np.vstack((irid.B_e.values, irid.B_n.values, irid.B_r.values))\n irid_coords = np.vstack((irid.lon.values, irid.lat.values, irid.r.values))\n\n # SuperMAG data:\n smag = supermag.loc[t0:t1, :]\n smag_B = np.vstack((smag.Be.values, smag.Bn.values, smag.Bu.values))\n smag_coords = np.vstack((smag.lon.values, smag.lat.values))\n\n # SuperDARN data:\n sd = superdarn.loc[t0:t1, :]\n vlos = sd['vlos'].values\n sd_coords = np.vstack((sd['glon'].values, sd['glat'].values))\n los = np.vstack((sd['le'].values, sd['ln'].values))\n\n\n # Make the data objects. The scale keyword determines a weight for the dataset. Increase it to reduce weight\n iridium_data = lompe.Data(irid_B * 1e-9, irid_coords, datatype = 'space_mag_fac', scale = 200e-9)\n supermag_data = lompe.Data(smag_B * 1e-9, smag_coords, datatype = 'ground_mag' , scale = 100e-9)\n superdarn_data = lompe.Data(vlos , sd_coords , LOS = los, datatype = 'convection' , scale = 500 )\n\n return(iridium_data, supermag_data, superdarn_data)","def get_dataitems_for_experiment(self, id):\n experiment = Experiment.get(id)\n dataitems = []\n for expgroup in experiment.experimentgroups:\n dataitems.extend(self.get_dataitems_for_experimentgroup(expgroup.id))\n return dataitems","def get_data(self):\n\n self.read_expression()\n self.read_tfs()\n self.read_metadata()\n self.set_gold_standard_and_priors()","def Test_data():\n print (\"loading test data ...\")\n time_start = time.time()\n data_root = '/media/keziwen/86AA9651AA963E1D'\n\n with h5py.File(join(data_root, './data/test_real2.h5')) as f:\n test_real = f['test_real'][:]\n with h5py.File(join(data_root, './data/test_imag2.h5')) as f:\n test_imag = f['test_imag'][:]\n test_real = np.transpose(test_real, (0, 1, 3, 2))\n test_imag = np.transpose(test_imag, (0, 1, 3, 2))\n test_data = test_real+1j*test_imag\n time_end = time.time()\n print ('dataset has been created using {}s'.format(time_end - time_start))\n return test_data","def get_data():\n pass","def fill_dataset(self):\n rm, rstd = self.get_rolling_stats()\n\n self.add_rolling_mean(rm)\n self.add_bollinger_bands(rstd)\n self.add_spy_info()\n self.add_beta_and_sharpe()\n self.add_stlouis_data()","def main(self):\n\n assault_mech_df = self.get_mech_df(url=self.assault_url)\n heavy_mech_df = self.get_mech_df(url=self.heavy_url)\n medium_mech_df = self.get_mech_df(url=self.medium_url)\n light_mech_df = self.get_mech_df(url=self.light_url)\n all_weights_df = pd.concat([assault_mech_df, heavy_mech_df, medium_mech_df, \n light_mech_df])\n\n self.save_data(assault_mech_df, \"assault\")\n self.save_data(heavy_mech_df, \"heavy\")\n self.save_data(medium_mech_df, \"medium\")\n self.save_data(light_mech_df, \"light\")\n self.save_data(all_weights_df, \"all_weights\")\n #get maximum new columns needed for splitting variants\n max_cols = all_weights_df.variants.apply(lambda x: len(x)).max()\n melt_cols = []\n\n for i in range(max_cols):\n all_weights_df[\"var_\"+str(i)] = \"\"\n melt_cols.append(\"var_\"+str(i))\n\n variant_weights_df = pd.DataFrame()\n for index, row in all_weights_df.iterrows():\n for i in range(len(row[\"variants\"])):\n #add each variant to variant weights as a row with mech, tonnage, variant\n new_row_dict = {\n \"mech_name\":row[\"mechs\"],\n \"tonnage\":row[\"tonnage\"],\n \"variant\":row[\"variants\"][i].upper()\n }\n new_row_df = pd.DataFrame(new_row_dict, index=[0])\n variant_weights_df = pd.concat([variant_weights_df, new_row_df])\n\n for i in range(len(row[\"hero_chassis\"])):\n new_row_dict = {\n \"mech_name\":row[\"hero_names\"],\n \"tonnage\":row[\"tonnage\"],\n \"variant\":row[\"hero_chassis\"][i].upper()\n }\n new_row_df = pd.DataFrame(new_row_dict, index=[0])\n variant_weights_df = pd.concat([variant_weights_df, new_row_df])\n\n\n for i in range(len(row[\"special_variants\"])):\n new_row_dict = {\n \"mech_name\":row[\"mechs\"],\n \"tonnage\":row[\"tonnage\"],\n \"variant\":row[\"special_variants\"][i].upper()\n }\n new_row_df = pd.DataFrame(new_row_dict, index=[0])\n variant_weights_df = pd.concat([variant_weights_df, new_row_df]) \n\n #add champion variants by matching on \n for i in range(len(row[\"champion_variants\"])):\n new_row_dict = {\n \"mech_name\":row[\"mechs\"],\n \"tonnage\":row[\"tonnage\"],\n \"variant\":row[\"champion_variants\"][i].upper()\n }\n new_row_df = pd.DataFrame(new_row_dict, index=[0])\n variant_weights_df = pd.concat([variant_weights_df, new_row_df])\n #remove duplicate rows \n variant_weights_df = variant_weights_df[variant_weights_df.duplicated(keep=\"first\")==False]\n self.save_data(variant_weights_df, \"variant_weights\")","def all_data(self):\n return pd.concat([self.historic_data, self.dayahead_data])","def get_raw_data(self, dataset):\n\t\tprint(\"Getting raw data for\", dataset)\n\t\tself.fetched[dataset] = fetch_20newsgroups(remove = ('headers', 'footers', 'quotes'), subset = dataset)\n\t\tself.raw_documents[dataset] = self.fetched[dataset].data\n\t\tself.Y[dataset] = self.fetched[dataset].target","def collect_data():\n\n \"Aqui va el codigo de alberto para recoger los datos que puede venir en forma de diccionario\"\n #TODO: Función para recoger los datos de los bms y meterlos en diccionarios (Alberto jr.)\n\n bms1 = dict()\n bms2 = dict()\n bms3 = dict()\n general = dict()\n\n\n # Ejemplos de datos para meter en los diccionarios\n\n temperature = 35.5\n voltage1 = 15.2\n voltage2 = 14.8\n date = time.strftime(\"%Y-%m-%d\") # Current date\n t = time.strftime(\"%H:%M:%S\") # Current time\n\n return bms1, bms2, bms3, general","def read_dataset_v1():\n path = load_config()\n T = feather.read_dataframe(path['data_dir'] / 'T_dat.feather')\n E = feather.read_dataframe(path['data_dir'] / 'E_dat.feather')\n M = feather.read_dataframe(path['data_dir'] / 'Meta.feather')\n data = sio.loadmat(path['data_dir'] / 'highvar_genes.mat', squeeze_me=True)\n return T, E, M, data","def getAllMeasurement(self): \n return self.measurement","def get_raw_x_data(\n params, fold, subject_list,\n):\n X = []\n\n for subject in subject_list:\n rsfmri_data = load_intertva_rsfmri(\n subject, os.path.join(params[\"orig_path\"], \"features_rsfMRI\")\n )\n\n if params[\"modality\"] == \"gyrification\":\n gyr_data = np.load(\n os.path.join(\n params[\"orig_path\"],\n \"features_gyrification\",\n \"{}_eig_vec_{}_onref_{}.npy\".format(\n subject, params[\"template\"], params[\"ref_subject\"]\n ),\n )\n )\n x_sub_data = np.concatenate([gyr_data, rsfmri_data], axis=1)\n elif params[\"modality\"] == \"tfMRI\":\n tfmri_data = load_intertva_tfmri(\n subject, os.path.join(params[\"orig_path\"], \"features_tfMRI\")\n )\n x_sub_data = np.concatenate([tfmri_data, rsfmri_data], axis=1)\n X.append(x_sub_data)\n\n return X\n # interTVA data has already been run on taskFMRI, on frioul","def extract_data():\n logging.info(f'Reading data from {impftermine.agg_export_file_name()}...')\n df_wl = pd.read_csv(impftermine.agg_export_file_name())\n vacc_report_file = os.path.join(credentials.vmdl_path, 'vaccination_report_bs_age_group_long.csv')\n logging.info(f'Reading data from {vacc_report_file}...')\n df_impf = pd.read_csv(vacc_report_file)\n return df_wl, df_impf","def gatherData(self):\n dagPath, components = self.__getGeometryComponents()\n self.gatherInfluenceWeights(dagPath, components)\n self.gatherBlendWeights(dagPath, components)\n\n for attr in ['skinningMethod', 'normalizeWeights']:\n self.data[attr] = cmds.getAttr('%s.%s' % (self.node, attr))","def setup(self):\n in_dataset, out_dataset = self.get_datasets()","def setup(self):\n in_dataset, out_dataset = self.get_datasets()","def getdata(verbose=True, filenameext=None):\n savepath = 'O:/Administration/02 - Økonomi og PDK/Medarbejdermapper/Kasper/Focus1 - Ad hoc opgaver/Lungemed sengedage og visitationer/plots/'\n\n if verbose: print(' - Getting LPR3 data from parsing SQL query for \"bed days\" ')\n savefilename_days = savepath+'lungemedLPR3_SQLbeddays.xlsx'\n filepath = savepath+'/../Lungemed.sql'\n if filenameext is not None:\n savefilename_days = savefilename_days.replace('.xlsx', filenameext+'.xlsx')\n filepath = filepath.replace('.sql', filenameext+'.sql')\n overwrite_days = True\n dataframe_days = gdf.returndatapull(lbv.loadSQL_beddays(filepath=filepath), verbose=verbose, savefilename=savefilename_days, overwrite=overwrite_days)\n\n if verbose: print(' - Getting LPR3 data from parsing SQL query for \"visitations\" ')\n savefilename_vis = savepath+'lungemedLPR3_SQLvisitations.xlsx'\n filepath = savepath + '/../Lungemed_visitationsoprindelse_nogroup.sql'\n if filenameext is not None:\n savefilename_vis = savefilename_vis.replace('.xlsx', filenameext+'.xlsx')\n filepath = filepath.replace('.sql', filenameext + '.sql')\n overwrite_vis = True\n dataframe_vis = gdf.returndatapull(lbv.loadSQL_visitations(filepath=filepath), verbose=verbose, savefilename=savefilename_vis, overwrite=overwrite_vis)\n\n return dataframe_days, dataframe_vis","def InitDataset(self):\n train_txt = 'ImageSets/Main/train.txt'\n val_txt = 'ImageSets/Main/val.txt'\n annotations = \"Annotations\"\n jpegimages = \"JPEGImages\"\n images_path = train_txt if (self.is_train) else val_txt \n images_path = readTxt(os.path.join(self.path, images_path))\n images_path.pop(-1)\n # rawdata format: [path_2_image, path_2_xml]\n rawData = list()\n for each in images_path:\n xml = os.path.join(self.path, annotations, each + '.xml')\n jpeg = os.path.join(self.path, jpegimages, each + '.jpg')\n rawData.append([jpeg, xml])\n return rawData","def _compute_experiment_statistics(self):\n pass","def init_data(self):\n fields = SeriesRepository.get_available_series().exclude(identifier=None)\n\n if self.catalog:\n try:\n catalog = Catalog.objects.get(identifier=self.catalog)\n except Catalog.DoesNotExist:\n return\n\n fields = fields.filter(\n distribution__dataset__catalog=catalog\n )\n\n fields = fields.prefetch_related(\n 'distribution',\n 'distribution__dataset',\n 'distribution__dataset__catalog',\n 'enhanced_meta',\n )\n all_meta = Metadata.objects.all()\n field_ct = ContentType.objects.get_for_model(Field)\n for field in fields:\n meta = json.loads(field.metadata)\n dist_meta = json.loads(field.distribution.metadata)\n dataset_meta = json.loads(field.distribution.dataset.metadata)\n themes = field.distribution.dataset.themes\n theme_labels = get_theme_labels(json.loads(themes)) if themes else ''\n\n self.fields[field.identifier] = {\n 'dataset': field.distribution.dataset,\n 'distribution': field.distribution,\n 'serie': field,\n 'serie_titulo': field.title,\n 'serie_unidades': meta.get('units'),\n 'serie_descripcion': meta.get('description'),\n 'distribucion_titulo': dist_meta.get('title'),\n 'distribucion_descripcion': dist_meta.get('description'),\n 'distribucion_url_descarga': field.distribution.download_url,\n 'dataset_responsable': dataset_meta.get('publisher', {}).get('name'),\n 'dataset_fuente': dataset_meta.get('source'),\n 'dataset_titulo': field.distribution.dataset.title,\n 'dataset_descripcion': dataset_meta.get('description'),\n 'dataset_tema': theme_labels,\n 'metadata': {o.key: o.value for o in list(all_meta.filter(content_type=field_ct, object_id=field.id))},\n 'frequency': self.serie_periodicity(field),\n }","def make_all(self):\n # General matrices #\n self.tsv_seq_to_concepts()\n self.tsv_seq_to_names()\n self.list_sequence_concept()\n # Only in the with 'samples' case #\n if self.a.abundances: self.tsv_samples_to_names()\n if self.a.abundances: self.biom_output()\n # Graphical outputs #\n self.per_seq_dot_files()\n if self.a.abundances: self.per_sample_dot_files()","def read_statistics(self):\n self.psdata=[]\n self.powerspectra=[]\n self.ds=[]\n self.dsigmasq=[]\n self.dsigma=[]\n self.bsdata=[]\n self.eqbispectra=[]\n self.fNLeq=[]\n\n for sub in range(self.Nsubs):\n self.psdata.append(np.load(self.datadir+self.filebase+\"_\"+str(sub)+\".npy\"))\n self.powerspectra.append(np.trim_zeros(self.psdata[-1][0][1:]))\n self.bsdata.append(np.load(self.datadir+self.fbbispec+\"_\"+str(sub)+\".npy\"))\n self.eqbispectra.append(self.bsdata[-1][0][1:len(self.powerspectra[-1])])\n\n self.ds.append(np.load(self.datadir+\"stat_\"+str(sub)+\".npy\")[0])\n self.dsigmasq.append(np.load(self.datadir+\"stat_\"+str(sub)+\".npy\")[1])\n self.dsigma = np.array([np.sqrt(dsq) for dsq in self.dsigmasq])\n\n self.klist=np.arange(1, len(self.powerspectra[-1]))*(2.*np.pi/self.Lsub)\n # subtract the mean ds\n self.ds = self.ds - np.mean(self.ds)\n self.fNLeq=np.mean(self.eqbispectra, axis=0)\n self.fNLeqsubs=np.mean(self.eqbispectra, axis=1)\n self.fNLeqds=[]\n for i in range(len(self.eqbispectra)):\n self.fNLeqds.append(np.array([self.ds[i]*self.eqbispectra[i][j] for j in range(45)]))","def build_dataset(self):\n print(\"reading data of images currently , please wait......\")\n x_train, y_train, _ = get_images(self.train_directory)\n x_test, y_test, _ = get_images(self.test_directory)\n x_train, y_train = image_subset(self.num_classes, x_train, y_train)\n x_test, y_test = image_subset(self.num_classes, x_test, y_test)\n x_train = x_train.astype('float32')\n x_test = x_test.astype('float32')\n self.x_train = x_train / 255\n self.x_test = x_test / 255\n self.y_train = utils.to_categorical(y_train, self.num_classes)\n self.y_test = utils.to_categorical(y_test, self.num_classes)","def _get_datas(self):\n print(f'base name {self.base_name}')\n data_file_name = glob(osp.join(self.root_dir, MERGED_PATTERN))[0]\n data_df = pd.read_csv(data_file_name)\n\n ppg_d = data_df[['CurrentTimeMillis', 'ch1']].values\n acc_d = data_df[[\n 'EventTimestamp(ns)', 'accel_x', 'accel_y', 'accel_z'\n ]].values\n ppg_d = ppg_d[::2]\n acc_d = acc_d[::2]\n\n return acc_d, ppg_d","def getTrainingData(self):\n raise NotImplementedError","def main():\n parser = argparse.ArgumentParser(description=\"Process the results of an experiment.\")\n parser.add_argument(\"experiment\")\n arguments = parser.parse_args()\n path = f\"experiments/{arguments.experiment}\"\n if not os.path.exists(path):\n raise SystemExit(f\"Path {path} does not exists.\")\n\n # For efficiency, one should generate the results from the parts without merging them.\n files = [file for file in os.listdir(path) if os.path.isfile(os.path.join(path, file))]\n frames = []\n for file in files:\n device, experiment, _ = file.split(\".\")\n frame = pandas.read_csv(\n os.path.join(path, file),\n index_col=\"variable\",\n usecols=[\"variable\", \"group_index\", \"value_i\"], dtype={\"value_i\": \"Int64\"}\n )\n frame[\"board\"] = device\n frame[\"experiment\"] = experiment\n frames.append(frame)\n dataframe = pandas.concat(frames)\n frames = None\n\n current_grouping = dataframe.groupby([\"group_index\", \"variable\"])\n \n data = current_grouping.agg([\n numpy.median,\n _percentile_factory(95),\n numpy.mean,\n numpy.std,\n \"count\"\n ])\n\n print(data)\n \n data = data.droplevel([0], axis=1)\n data = data.unstack()\n data.columns = data.columns.map('_'.join)\n data.to_csv(f\"{arguments.experiment}.csv\")","def get_measurements_by_time(self):\n data_path = os.path.abspath(\n os.path.join(\n os.path.dirname(os.path.realpath(__file__)),\n \"..\",\n \"data/NVB_rescale_dataset.p\",\n )\n )\n self.log_print([\"Getting experimental data from {}\".format(data_path)])\n self.measurements = pickle.load(open(data_path, \"rb\"))\n return self.measurements","def fetch_test_data(self):\r\n self.fetch_attribute_list()\r\n self.type_conversion()\r\n # Connect to sensor database.\r\n connection = db.Connection(host=\"localhost\", user=\"root\", db=\"sensor\")\r\n dbhandler = connection.cursor()\r\n test_data = []\r\n for i in range(0, len(self.attribute_list)):\r\n # If the value is in user_info.json file.\r\n if self.attribute_list[i] in self.form_attribute_keys == True:\r\n test_data.append(self.form_attribute[self.attribute_list[i]])\r\n else:\r\n # Value is in database.\r\n # Reconstruct attribute name to match with table column name.\r\n self.attribute_list[i] = self.attribute_list[i].replace(' ', '_')\r\n self.attribute_list[i] = self.attribute_list[i].lower()\r\n # Fetch last inserted value of that attribute.\r\n query = \"select `\"\r\n query += (self.attribute_list[i] + \"`FROM `\" + self.attribute_list[i]\r\n + \"` ORDER BY `\" + self.attribute_list[i] + \"` DESC LIMIT 1\")\r\n dbhandler.execute(query=query)\r\n value = dbhandler.fetchall()\r\n print value\r\n # Append to test_data\r\n test_data.append(value[0][0])\r\n print test_data\r\n return np.array(test_data)","def extract(self):\n\n # print some infos about data\n print(\"\\n--extract batches from data:\\ntrain: {}\\nval: {}\\ntest: {}\\n\".format(self.data[0]['x'].shape, self.data[1]['x'].shape, self.data[2]['x'].shape))\n\n # create batches\n self.x_train, self.y_train, _ = self.create_batches(self.data[0], batch_size=self.batch_size)\n self.x_val, self.y_val, _ = self.create_batches(self.data[1], batch_size=self.batch_size_eval)\n self.x_test, self.y_test, _ = self.create_batches(self.data[2], batch_size=self.batch_size_eval)\n\n # my data\n if len(self.mfcc_data_files) == 4:\n self.x_my, self.y_my, self.z_my = self.create_batches(self.data[3], batch_size=1)","def template_dataset(self):\n exp_dict = {\n 'experiment_name': 'ALLEN_all_neurons',\n 'only_process_n': None, # Set to None to process all\n 'randomize_selection': True,\n 'reference_image_key': {'proc_stimuli': 'image'},\n 'reference_label_key': {'neural_trace_trimmed': 'label'},\n 'rf_query': [{\n 'rf_coordinate_range': { # Get all cells\n 'x_min': 40,\n 'x_max': 70,\n 'y_min': 20,\n 'y_max': 50,\n },\n 'cre_line': 'Cux2',\n 'structure': 'VISp'}\n ],\n 'cross_ref': 'rf_coordinate_range_and_stimuli',\n 'store_means': [\n 'image',\n 'label'\n ],\n 'cc_repo_vars': {\n 'output_size': [2, 1], # target variable -- neural activity,\n 'model_im_size': [152, 304, 1],\n 'loss_function': 'pearson',\n 'score_metric': 'pearson',\n 'preprocess': 'resize'\n },\n # 'deconv_method': 'elephant'\n }\n exp_dict = self.add_globals(exp_dict)\n return exp_dict","def get_data(dataset, **kwargs):\n age_df = load_age_sample_from_mcmc_chains(dataset, **kwargs)\n hr_df = load_hr()\n age_df, hr_df = clean_data(age_df, hr_df)\n snids = age_df.index.unique().tolist()\n return snids, age_df, hr_df","def get_uniform_dist_data(debug, dataset, resamplefactor, raw, analysis):\n\n project_wd, project_data, project_sink = get_paths(debug, dataset)\n\n demographics, imgs, dataframe = get_data(project_data, dataset,\n debug, project_wd,\n resamplefactor,\n raw=raw,\n analysis=analysis)\n\n # transform age into ints\n demographics['age_int'] = demographics['age'].astype('int32', copy=False)\n\n # Select 14 subjects for all ages that have 14 representatives.\n age_range = np.arange(demographics['age'].min(), demographics['age'].max())\n # remove entry where you don't have 14 subjects\n max_n = 14\n age_to_remove = [35, 36, 39, 42, 78, 79, 80, 81, 82, 83, 85, 89]\n age_range = np.setdiff1d(age_range, age_to_remove)\n # iterate over the dataframe and select 14 subjects for each age range\n ids_to_use = []\n for age in age_range:\n ids_to_use.append(demographics.index[demographics['age_int'] ==\n age].tolist()[:max_n])\n\n # flatten ids_to_use\n ids_to_use = [item for sublist in ids_to_use for item in sublist]\n # Filter the demographics dataframe\n demographics = demographics[demographics.index.isin(ids_to_use)]\n # set subject's id as index\n # filter dataset using index of the subjects\n dataframe = dataframe.loc[demographics['id']]\n\n # Print some diagnosis\n print('Shape of the new demographics:')\n print(demographics.shape)\n print('Oldest %d and youngest %d subject' %(demographics['age_int'].max(),\n demographics['age_int'].min()))\n print('Number of age bins %d' %len(demographics['age_int'].unique()))\n return demographics, dataframe","def lego_sets():\n \n \n data_test=data_specific\n\n\n\n \n \n\n \n print(data_test)\n print(\"The size of the data is: \",len(data_test))\n \n \n \n # you must replace this line and return your own list\n return data_test","def get_datadfs(self, recal=True):\n\n # those files contain score >1\n trn_fname = os.path.join(self.save_dir, 'reg_trn_set_df.csv')\n val_fname = os.path.join(self.save_dir, 'reg_val_set_df.csv')\n tst_fname = os.path.join(self.save_dir, 'reg_tst_set_df.csv')\n\n if os.path.exists(trn_fname) and os.path.exists(val_fname) and os.path.exists(tst_fname) and not recal:\n logging.info('reading...\\n{}\\n{}\\n{}'.format(trn_fname, val_fname, tst_fname))\n trn_set_df = pd.read_csv(trn_fname, sep='\\t')\n val_set_df = pd.read_csv(val_fname, sep='\\t')\n tst_set_df = pd.read_csv(tst_fname, sep='\\t')\n else:\n # read phage and bact relation file\n data_meta_info_f = self.config['data_meta_info']\n if not os.path.exists(data_meta_info_f):\n logging.error('data meta information file not Found. {}'.format(data_meta_info_f))\n raise FileNotFoundError('data meta information file not Found')\n data_info = pd.read_csv(data_meta_info_f)\n logging.info('total samples: {}'.format(len(data_info)))\n\n # select specific columns\n sel_cols = 'hostID,phageID,b_Score,phage_bac_name,bac_len,phage_len'.split(',')\n data_info_df = data_info[sel_cols]\n\n # select rows with score > 1\n data_info_sel = data_info_df[data_info_df['b_Score'] > 1].copy()\n data_info_sel.reset_index(drop=True, inplace=True)\n\n b_scores = data_info_sel['b_Score'].values\n b_scores = b_scores.reshape(-1, 1)\n\n # MinMaxScaler()\n mm_scaler = MinMaxScaler()\n mm_scaler.fit(b_scores)\n mm_scaler_fname = os.path.join(self.save_dir, 'minmax_scaler.joblib')\n if os.path.exists(mm_scaler_fname):\n os.remove(mm_scaler_fname)\n dump(mm_scaler, mm_scaler_fname)\n data_info_sel['minmax_bscore'] = np.squeeze(mm_scaler.transform(b_scores))\n\n # StandardScaler()\n ss_scaler = StandardScaler()\n ss_scaler.fit(b_scores)\n ss_scaler_fname = os.path.join(self.save_dir, 'standard_scaler.joblib')\n if os.path.exists(ss_scaler_fname):\n os.remove(ss_scaler_fname)\n dump(ss_scaler, ss_scaler_fname)\n data_info_sel['norm_bscore'] = np.squeeze(ss_scaler.transform(b_scores))\n\n # MaxAbsScaler()\n ma_scaler = MaxAbsScaler()\n ma_scaler.fit(b_scores)\n ma_scaler_fname = os.path.join(self.save_dir, 'maxabs_scaler.joblib')\n if os.path.exists(ma_scaler_fname):\n os.remove(ma_scaler_fname)\n dump(ma_scaler, ma_scaler_fname)\n data_info_sel['maxabs_bscore'] = np.squeeze(ma_scaler.transform(b_scores))\n\n logging.info('number of samples with score > 1 : {}'.format(len(data_info_sel)))\n\n # creat train, validation and test dataset\n # split dataframe, 80% for train , 10% for validation and 10% for test\n trn_set_df, val_set_df, tst_set_df = np.split(data_info_sel.sample(frac=1, random_state=1),\n [int(.7*len(data_info_sel)), int(.85*len(data_info_sel))])\n\n trn_set_df.reset_index(drop=True, inplace=True)\n val_set_df.reset_index(drop=True, inplace=True)\n tst_set_df.reset_index(drop=True, inplace=True)\n\n if os.path.exists(trn_fname):\n os.remove(trn_fname)\n trn_set_df.to_csv(trn_fname, sep='\\t', index=False)\n if os.path.exists(val_fname):\n os.remove(val_fname)\n val_set_df.to_csv(val_fname, sep='\\t', index=False)\n if os.path.exists(tst_fname):\n os.remove(tst_fname)\n tst_set_df.to_csv(tst_fname, sep='\\t', index=False)\n\n logging.info('train sample: {}'.format(len(trn_set_df)))\n logging.info('valid sample: {}'.format(len(val_set_df)))\n logging.info('test sample: {}'.format(len(tst_set_df)))\n\n return trn_set_df, val_set_df, tst_set_df","def datasets(self):\n return [Dataset.ENSEMBL]","def _make_meta(self):\n available_meas_times = list()\n available_intervals = list()\n drill_by = list()\n related = list()\n last_data_set_instance = dict()\n\n if self._data['report_save_historical_instances_ind'] == 'Y':\n # last measurement instance\n res = self._db.Query(\"\"\"SELECT *\n FROM report_data_set_instance\n WHERE\n `element_id`=%s\n AND `segment_value_id` = %s\n ORDER BY measurement_time DESC\n LIMIT 0, 1\"\"\",(self._id, self._segment_value_id))\n if res:\n last_data_set_instance = self._db.record[0]\n last_data_set_instance['measurement_time'] = self._formatter.format_date(last_data_set_instance['measurement_time'])\n\n # available measurement instances\n res = self._db.Query(\"\"\"SELECT *\n FROM report_data_set_instance\n WHERE\n `element_id`=%s\n AND `segment_value_id` = %s\n ORDER BY measurement_time DESC\"\"\",(self._id, self._segment_value_id))\n if res:\n for data_set_instance in self._db.record:\n data_set_instance['measurement_time'] = self._formatter.format_date(data_set_instance['measurement_time'])\n available_meas_times.append(data_set_instance)\n \n\n # get drill by. not for this version\n\n # available measurement intervals\n if self._data['report_primary_shared_dimension_id'] is None:\n self._data['report_primary_shared_dimension_id'] = 0\n\n self._db.Query(\"\"\"\n SELECT measurement_interval.*,\n dashboard_element.element_id\n FROM dashboard_element\n LEFT JOIN measurement_interval\n ON measurement_interval.measurement_interval_id = dashboard_element.measurement_interval_id\n WHERE\n (dashboard_element.`element_id`<>%s\n AND dashboard_element.measurement_interval_id <> %s\n AND dashboard_element.shared_measure_id = %s\n AND dashboard_element.`type` = 'internal report'\n AND ifnull(dashboard_element.report_used_for_drill_to_ind,'N') = %s\n AND ifnull(dashboard_element.report_primary_shared_dimension_id,0) = %s\n AND ifnull(dashboard_element.segment_id,0) = %s)\n OR\n dashboard_element.`element_id`=%s\n AND 3=4\n \n GROUP BY measurement_interval.measurement_interval_id\n ORDER BY\n measurement_interval.display_sequence,\n dashboard_element.name ASC\n \"\"\",\n (self._id,\n self._data['measurement_interval_id'],\n self._data['shared_measure_id'],\n self._data['report_used_for_drill_to_ind'],\n self._data['report_primary_shared_dimension_id'],\n self._data['segment_id'],\n self._id))\n\n\n for interval in self._db.record:\n interval['report_data_set_instance_id'] = 0\n available_intervals.append(interval)\n\n # see related\n self._db.Query(\"\"\"SELECT e.*\n FROM dashboard_element_topic det, dashboard_element e\n WHERE e.element_id = det.dashboard_element_id\n AND dashboard_element_id <> %s\n AND e.enabled_ind = 'Y'\n AND topic_id IN (select topic_id from dashboard_element_topic where dashboard_element_id = %s)\n UNION SELECT e.*\n FROM dashboard_element e, metric_drill_to_report m\n WHERE m.metric_element_id = e.element_id\n AND m.report_element_id = %s\n AND e.enabled_ind = 'Y'\n AND ifnull(e.segment_id,0) = %s\n \"\"\", (self._id, self._id, self._id, self._data['segment_id']))\n \n\n for related_element in self._db.record:\n if not related_element['segment_id']:\n related_element['segment_id'] = 0\n if related_element['segment_id'] == self._data['segment_id']:\n related_element['segment_value_id'] = self._segment_value_id\n else:\n related_element['segment_value_id'] = 0\n related.append(related_element)\n\n # elements displayed on the page\n before_dataset = list()\n after_dataset = list()\n \n charts_before_dataset = list()\n charts_after_dataset = list()\n \n \n # dataset table\n dataset_el = OrderedDict()\n dataset_el['element_id'] = ''\n dataset_el['element_type'] = 'dataset'\n dataset_el['element_name'] = ''\n dataset_el['element_desc'] = ''\n dataset_el['placement'] = ''\n dataset_el['sequence'] = 0\n dataset_el['show_ind'] = self._data['show_data_set_table_in_report_ind']\n \n \n # charts\n self._db.Query(\"\"\"SELECT *\n FROM report_data_set_chart \n WHERE \n `element_id`= %s\n AND \n (ISNULL(report_data_set_pivot_id)\n OR report_data_set_pivot_id = 0) \n ORDER BY display_sequence ASC\"\"\", (self._id, ))\n for chart in self._db.record:\n chart_el = OrderedDict()\n chart_el['element_id'] = chart['report_data_set_chart_id']\n chart_el['element_type'] = 'chart'\n chart_el['pivot_id'] = 0\n if chart['report_data_set_pivot_id']:\n chart_el['pivot_id'] = chart['report_data_set_pivot_id']\n chart_el['element_name'] = chart['name']\n chart_el['element_desc'] = chart['description']\n chart_el['placement'] = chart['chart_placement']\n chart_el['sequence'] = chart['display_sequence']\n chart_el['show_ind'] = chart['enabled_ind']\n if chart_el['placement'] == 'before table': \n charts_before_dataset.append(chart_el)\n else:\n charts_after_dataset.append(chart_el)\n \n # pivots\n self._db.Query(\"\"\"SELECT *\n FROM report_data_set_pivot\n WHERE\n `element_id`= %s\n ORDER BY display_sequence ASC\"\"\", (self._id, ))\n for pivot in self._db.record:\n before_pivot = list()\n after_pivot = list()\n #pivot_element = list()\n \n pivot_el = OrderedDict()\n pivot_el['element_id'] = pivot['report_data_set_pivot_id']\n pivot_el['element_type'] = 'pivot'\n pivot_el['element_name'] = pivot['name']\n pivot_el['element_desc'] = ''\n pivot_el['placement'] = pivot['pivot_table_report_placement']\n pivot_el['sequence'] = pivot['display_sequence']\n pivot_el['show_ind'] = pivot['enabled_ind']\n \n # charts\n self._db.Query(\"\"\"SELECT *\n FROM report_data_set_chart \n WHERE \n `element_id`= %s\n AND report_data_set_pivot_id = %s \n ORDER BY display_sequence ASC\"\"\",\n (self._id, pivot_el['element_id']))\n for chart in self._db.record:\n chart_el = OrderedDict()\n chart_el['element_id'] = chart['report_data_set_chart_id']\n chart_el['element_type'] = 'chart'\n chart_el['pivot_id'] = 0\n if chart['report_data_set_pivot_id']:\n chart_el['pivot_id'] = chart['report_data_set_pivot_id']\n chart_el['element_name'] = chart['name']\n chart_el['element_desc'] = chart['description']\n chart_el['placement'] = chart['chart_placement']\n chart_el['sequence'] = chart['display_sequence']\n chart_el['show_ind'] = chart['enabled_ind']\n if chart_el['placement'] == 'before table': \n before_pivot.append(chart_el)\n else:\n after_pivot.append(chart_el)\n pivot_element = before_pivot + [pivot_el] + after_pivot \n \n if pivot_el['placement'] == 'before data set':\n before_dataset += pivot_element\n else:\n after_dataset += pivot_element\n elements = charts_before_dataset + before_dataset + [dataset_el] + after_dataset + charts_after_dataset\n \n \n self._jfile.make_current_meta(last_data_set_instance,\n available_meas_times,\n available_intervals,\n drill_by,\n related,\n elements,\n self._segment_values)","def _get_raw_data(self, idx=0):\n # Get the time step then make a data frame\n raise NotImplementedError('Code me up!')\n #data = self._data[???]\n return data","def get_stats():\n datasets = [\n (\"../data_processing/data/page2answer_single_abstractive_summ.json\", \"p2a-single-abs\"),\n (\"../data_processing/data/page2answer_single_extractive_summ.json\", \"p2a-single-ext\"),\n (\"../data_processing/data/section2answer_multi_abstractive_summ.json\", \"s2a-multi-abs\"),\n (\"../data_processing/data/page2answer_multi_extractive_summ.json\", \"p2a-multi-ext\"),\n (\"../data_processing/data/section2answer_single_abstractive_summ.json\", \"s2a-single-abs\"),\n (\"../data_processing/data/section2answer_single_extractive_summ.json\", \"s2a-single-ext\"),\n (\"../data_processing/data/section2answer_multi_extractive_summ.json\", \"s2a-multi-ext\"),\n (\"../data_processing/data/question_driven_answer_summarization_primary_dataset.json\", \"complete_dataset\"),\n ]\n\n stats = SummarizationDataStats()\n for dataset in datasets:\n print(dataset[1])\n stats.load_data(dataset[0], dataset[1])\n stats.iterate_data()","def _data(self) -> List[Data]:\n data = []\n sample_ids, repeated_sample_ids = set(), set()\n for datum in self.collection.data.filter(\n type=self.process_type,\n status=\"OK\",\n ordering=\"-created\",\n fields=self.DATA_FIELDS,\n ):\n # 1 Filter by newest datum in the sample\n if datum.sample.id in sample_ids:\n repeated_sample_ids.add(datum.sample.id)\n continue\n\n # 2 Filter by genes, if geneset is given\n if self.geneset:\n obj_geneset = self._get_obj_geneset(datum)\n if not self.geneset.issubset(obj_geneset):\n warnings.warn(\n f\"Sample {datum.sample} (Data {datum.id}) does not \"\n \"contain the genes requested in geneset input.\"\n )\n continue\n\n sample_ids.add(datum.sample.id)\n data.append(datum)\n\n if repeated_sample_ids:\n repeated = \", \".join(map(str, repeated_sample_ids))\n warnings.warn(\n f\"The following samples have multiple data of type {self.process_type}: \"\n f\"{repeated}. Using only the newest data of this sample.\",\n UserWarning,\n )\n\n if not data:\n raise ValueError(\n f\"Collection {self.collection.name} has no {self.process_type} \"\n \"data or there is no data with the requested mutations.\"\n )\n\n return data","def decode(self):\n # Extract all the experiments\n\n # Map of imageset/scan pairs\n imagesets = {}\n\n # For every experiment, use the given input to create\n # a sensible experiment.\n el = ExperimentList()\n for eobj in self._obj[\"experiment\"]:\n\n # Get the models\n identifier = eobj.get(\"identifier\", \"\")\n beam = self._lookup_model(\"beam\", eobj)\n detector = self._lookup_model(\"detector\", eobj)\n goniometer = self._lookup_model(\"goniometer\", eobj)\n scan = self._lookup_model(\"scan\", eobj)\n crystal = self._lookup_model(\"crystal\", eobj)\n profile = self._lookup_model(\"profile\", eobj)\n scaling_model = self._lookup_model(\"scaling_model\", eobj)\n\n key = (eobj.get(\"imageset\"), eobj.get(\"scan\"))\n\n imageset = None\n try:\n imageset = imagesets[key] # type: ImageSet\n except KeyError:\n # This imageset hasn't been loaded yet - create it\n imageset_data = self._lookup_model(\"imageset\", eobj)\n\n # Create the imageset from the input data\n if imageset_data is not None:\n if \"params\" in imageset_data:\n format_kwargs = imageset_data[\"params\"]\n else:\n format_kwargs = {}\n\n # Load the external lookup data\n mask_filename, mask = self._load_pickle_path(imageset_data, \"mask\")\n gain_filename, gain = self._load_pickle_path(imageset_data, \"gain\")\n pedestal_filename, pedestal = self._load_pickle_path(\n imageset_data, \"pedestal\"\n )\n dx_filename, dx = self._load_pickle_path(imageset_data, \"dx\")\n dy_filename, dy = self._load_pickle_path(imageset_data, \"dy\")\n\n if imageset_data[\"__id__\"] == \"ImageSet\":\n imageset = self._make_stills(\n imageset_data, format_kwargs=format_kwargs\n )\n elif imageset_data[\"__id__\"] == \"ImageGrid\":\n imageset = self._make_grid(\n imageset_data, format_kwargs=format_kwargs\n )\n elif (\n imageset_data[\"__id__\"] == \"ImageSequence\"\n or imageset_data[\"__id__\"] == \"ImageSweep\"\n ):\n imageset = self._make_sequence(\n imageset_data,\n beam=beam,\n detector=detector,\n goniometer=goniometer,\n scan=scan,\n format_kwargs=format_kwargs,\n )\n elif imageset_data[\"__id__\"] == \"MemImageSet\":\n imageset = self._make_mem_imageset(imageset_data)\n else:\n raise RuntimeError(\"Unknown imageset type\")\n\n if imageset is not None:\n # Set the external lookup\n if mask is None:\n mask = ImageBool()\n else:\n mask = ImageBool(mask)\n if gain is None:\n gain = ImageDouble()\n else:\n gain = ImageDouble(gain)\n if pedestal is None:\n pedestal = ImageDouble()\n else:\n pedestal = ImageDouble(pedestal)\n if dx is None:\n dx = ImageDouble()\n else:\n dx = ImageDouble(dx)\n if dy is None:\n dy = ImageDouble()\n else:\n dy = ImageDouble(dy)\n\n if not imageset.external_lookup.mask.data.empty():\n if not mask.empty():\n mask = tuple(m.data() for m in mask)\n for m1, m2 in zip(\n mask, imageset.external_lookup.mask.data\n ):\n m1 &= m2.data()\n imageset.external_lookup.mask.data = ImageBool(mask)\n else:\n imageset.external_lookup.mask.data = mask\n imageset.external_lookup.mask.filename = mask_filename\n imageset.external_lookup.gain.data = gain\n imageset.external_lookup.gain.filename = gain_filename\n imageset.external_lookup.pedestal.data = pedestal\n imageset.external_lookup.pedestal.filename = pedestal_filename\n imageset.external_lookup.dx.data = dx\n imageset.external_lookup.dx.filename = dx_filename\n imageset.external_lookup.dy.data = dy\n imageset.external_lookup.dy.filename = dy_filename\n\n # Update the imageset models\n if isinstance(imageset, ImageSequence):\n imageset.set_beam(beam)\n imageset.set_detector(detector)\n imageset.set_goniometer(goniometer)\n imageset.set_scan(scan)\n elif isinstance(imageset, (ImageSet, ImageGrid)):\n for i in range(len(imageset)):\n imageset.set_beam(beam, i)\n imageset.set_detector(detector, i)\n imageset.set_goniometer(goniometer, i)\n imageset.set_scan(scan, i)\n\n imageset.update_detector_px_mm_data()\n\n # Add the imageset to the dict - even if empty - as this will\n # prevent a duplicated attempt at reconstruction\n imagesets[key] = imageset\n\n # Append the experiment\n el.append(\n Experiment(\n imageset=imageset,\n beam=beam,\n detector=detector,\n goniometer=goniometer,\n scan=scan,\n crystal=crystal,\n profile=profile,\n scaling_model=scaling_model,\n identifier=identifier,\n )\n )\n\n # Return the experiment list\n return el","def get_content(self):\r\n return self.parameters, self.spectrum","def collect_data(self):\n exp_conf: ec.ExperimentConfiguration\n # Disabled multiprocess run because of huge memory usage\n processes_number = 1 # self._campaign_configuration['General']['j']\n if processes_number == 1:\n self._logger.info(\"-->Evaluate experiments (sequentially)\")\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\n exp_conf.evaluate()\n if bool(self._campaign_configuration['General']['generate_plots']):\n exp_conf.generate_plots()\n self._logger.info(\"<--\")\n else:\n self._logger.info(\"-->Evaluate experiments (in parallel)\")\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\n if bool(self._campaign_configuration['General']['generate_plots']):\n pool = multiprocessing.Pool(processes_number)\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\n self._logger.info(\"<--\")\n\n self.raw_results = {}\n for exp_conf in self._exp_confs:\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes","def process_raw_data(self):\n \n # Define some variables of interest.\n vor = [\"n_sentences\", \"n_correct\", \"p_correct\", \"median_RT\", \\\n \"mean_RT\", \"stdev_RT\", \"scaled_stdev_RT\"]\n \n # Get all participant names, or return straight away if no data was\n # loaded yet.\n if hasattr(self, \"raw\"):\n participants = self.raw.keys()\n participants.sort()\n else:\n self.data = None\n return\n\n # Count the number of participants.\n n = len(participants)\n \n # Create a data dict for each variable of interest.\n self.data = {}\n self.data[\"ppname\"] = []\n for var in vor:\n self.data[var] = numpy.zeros(n, dtype=float) * numpy.NaN\n \n # Loop through all participants.\n for i, ppname in enumerate(participants):\n # Add the participant name.\n self.data[\"ppname\"].append(copy.deepcopy(ppname))\n # Skip empty datasets.\n if self.raw[ppname] is None:\n continue\n # Compute stuff relevant to this task.\n self.data[\"n_sentences\"][i] = len(self.raw[ppname][\"Sentence\"])\n self.data[\"n_correct\"][i] = numpy.sum(self.raw[ppname][\"correct\"])\n self.data[\"p_correct\"][i] = float(self.data[\"n_correct\"][i]) \\\n / float(self.data[\"n_sentences\"][i])\n self.data[\"median_RT\"][i] = numpy.nanmedian(self.raw[ppname][\"RT\"])\n self.data[\"mean_RT\"][i] = numpy.nanmean(self.raw[ppname][\"RT\"])\n self.data[\"stdev_RT\"][i] = numpy.nanstd(self.raw[ppname][\"RT\"])\n # Compute a scaled standard deviation of the response time, scaled to the\n # median response time to remove the correlation between the two.\n self.data[\"scaled_stdev_RT\"] = self.data[\"stdev_RT\"] / self.data[\"median_RT\"]","def __getitem__(self, type: str):\n nodes = pandas.read_csv(join(self.base_path, \"nodes.csv\"))\n edges = pandas.read_csv(join(self.base_path, \"held.csv\"))\n if type == \"link\":\n # nodes = pandas.read_csv(join(self.base_path, \"nodes.csv\"))\n held = pandas.read_csv(join(self.base_path, \"held.csv\"))\n\n held = held.query('type == 8')[['src', 'dst']]\n\n # node_pool = set(self.splits[2])\n # held = keep_from_set(held, node_pool)\n\n return Experiment(self.embed, nodes, edges, held, split_on=\"nodes\", neg_sampling_strategy=\"word2vec\", compact_dst=False)\n\n elif type == \"apicall\":\n api_seq = pandas.read_csv(self.experiments['apicall'])\n\n # unique_nodes = set(nodes['id'].values.tolist())\n\n # api_seq_test = api_seq.copy()\n # api_seq_test['src'] = api_seq_test['src'].apply(lambda nid: nid if nid in unique_nodes else None)\n # api_seq_test['dst'] = api_seq_test['dst'].apply(lambda nid: nid if nid in unique_nodes else None)\n # api_seq_test.dropna(axis=0, inplace=True)\n\n # disabled for testing\n # api_seq = api_seq[\n # api_seq['src'].apply(lambda nid: nid in unique_nodes)\n # ]\n #\n # api_seq = api_seq[\n # api_seq['dst'].apply(lambda nid: nid in unique_nodes)\n # ]\n\n node_pool = set(self.splits[2])\n api_seq = keep_from_set(api_seq, node_pool)\n\n return Experiment(self.embed, nodes, edges, api_seq, split_on=\"nodes\", neg_sampling_strategy=\"word2vec\", compact_dst=False)\n\n elif type == \"typeuse\":\n held = pandas.read_csv(join(self.base_path, \"held.csv\"))\n\n held = held.query('type == 2')[['src', 'dst']]\n\n # node_pool = set(self.splits[2])\n # held = keep_from_set(held, node_pool)\n\n return Experiment(self.embed, nodes, edges, held, split_on=\"nodes\", neg_sampling_strategy=\"word2vec\", compact_dst=False)\n\n elif type == \"varuse\":\n var_use = pandas.read_csv(self.experiments['varuse'])\n\n # unique_nodes = set(nodes['id'].values.tolist())\n node_pool = set(self.splits[2])\n\n var_use = var_use[\n var_use['src'].apply(lambda nid: nid in node_pool)\n ]\n\n return Experiment2(self.embed, nodes, edges, var_use, split_on=\"nodes\", neg_sampling_strategy=\"word2vec\")\n\n elif type == \"fname\":\n\n # fname = pandas.read_csv(self.experiments['fname'])\n functions = nodes.query('label == 4096')\n functions['fname'] = functions['name'].apply(lambda name: name.split(\".\")[-1])\n\n functions['src'] = functions['id']\n functions['dst'] = functions['fname']\n\n # unique_nodes = set(nodes['id'].values.tolist())\n node_pool = set(self.splits[2])\n\n functions = functions[\n functions['src'].apply(lambda nid: nid in node_pool)\n ]\n\n # use edge splits when outgoing degree is 1\n\n return Experiment2(self.embed, nodes, edges, functions[['src', 'dst']], split_on=\"edges\", neg_sampling_strategy=\"word2vec\")\n\n elif type == \"nodetype\":\n\n types = nodes.copy()\n types['src'] = nodes['id']\n types['dst'] = nodes['label']\n\n print(\"WARNING: Make sure that you target label is stored in the field: label\")\n # raise Warning(\"Make sure that you target label is stored in the field: label\")\n\n node_pool = set(self.splits[2])\n\n types['src'] = types['src'].apply(lambda nid: nid if nid in node_pool else None)\n types = types.dropna(axis=0)\n\n return Experiment3(self.embed, nodes, edges, types[['src', 'dst']], split_on=\"edges\", neg_sampling_strategy=\"word2vec\")\n else:\n raise ValueError(f\"Unknown experiment: {type}. The following experiments are available: [apicall|link|typeuse|varuse|fname|nodetype].\")","def _load_data(self):\n\n path_data_x = '/workspace/base-ml/data/dizzyreg/t%s_df.csv' % \\\n self.task_num\n path_data_y = '/workspace/base-ml/data/dizzyreg/label_df_t%s.csv' % self.task_num\n path_meta = '/workspace/base-ml/data/dizzyreg/meta_df_t%s.csv' % self.task_num\n path_numerical_columns = '/workspace/base-ml/data/dizzyreg/num_columns_v2.csv'\n path_nonnumerical_columns = '/workspace/base-ml/data/dizzyreg/non_num_columns_v2.csv'\n\n read_data_x = pd.read_csv(path_data_x)\n read_data_y = pd.read_csv(path_data_y)\n read_data_meta = pd.read_csv(path_meta)\n\n # Drop columns if it only contains 1 unique element\n read_data_x = pd.DataFrame(self.drop_one_elem_columns(read_data_x))\n\n num_col = pd.read_csv(path_numerical_columns)\n num_col = read_data_x.columns.isin(num_col['0'].values).nonzero()[0]\n col_idx = np.arange(read_data_x.shape[-1])\n non_num_col = np.setdiff1d(col_idx, num_col)\n\n # new_data_x = np.array(read_data_x).astype(np.float32)\n new_data_x = np.array(read_data_x)\n new_data_y = np.array(read_data_y).astype(np.float32)\n new_data_meta = np.array(read_data_meta).astype(np.float32)\n\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\n\n\n # Winsorize dataset\n len_feat = new_data_x.shape[-1]\n idx_list = list(num_col)\n for i in range(len_feat):\n if i in idx_list:\n cur_data = new_data_x[:, i]\n cur_data = np.array(cur_data)\n lower_p = np.percentile(cur_data, 5)\n higher_p = np.percentile(cur_data, 95)\n cur_data[cur_data < lower_p] = lower_p\n cur_data[cur_data > higher_p] = higher_p\n new_data_x[:, i] = cur_data\n\n # Make sure target data is one-hot encoded\n if new_data_y.shape[-1] == 1:\n num_class = len(np.unique(new_data_y))\n new_data_y = np.eye(num_class)[new_data_y.astype(int).reshape(-1)]\n new_data_y = new_data_y.astype('float32')\n self.orig_column_names = read_data_x.columns\n self.data_x = new_data_x # N x F\n self.data_y = new_data_y # N x C\n self.numerical_idx = num_col # list of idx\n self.non_num_idx = non_num_col # None\n\n # Calculate adjacency matrix\n self.meta_inf = new_data_meta.astype('float32') # N x 3\n if self.args.graph_type:\n self.adj = self.get_adjacency()","def _generate_experimental_data(self):\n\n loginfo('Extracting dataset...')\n cfg = self.cfg_\n return ex.ExperimentalData(db=cfg.db,\n prediction_label=cfg.prediction_label,\n games=cfg.games,\n folds=cfg.training_rounds,\n fold_size=cfg.training_samples_per_round,\n grid_search_folds=cfg.grid_search_folds,\n grid_search_fold_size=\n cfg.grid_search_samples_per_fold,\n sampling=cfg.data_sampling,\n lognormal=cfg.lognormal,\n power_transform=cfg.power_transform,\n bin_ranges=cfg.bin_ranges,\n batch_size=self.batch_size_)","def GetData(self):\r\n if self.Error == False:\r\n Extra = {}\r\n try:\r\n result = {}\r\n temp = self.ScrapeMainWebpage()\r\n if temp != None:\r\n result.update(temp)\r\n temp = self.ScrapeParameters1Webpage()\r\n if temp != None:\r\n result.update(temp)\r\n temp = self.ScrapeParameters2Webpage()\r\n if temp != None:\r\n result.update(temp)\r\n temp = self.ScrapeStatusWebpage()\r\n if temp != None:\r\n result.update(temp)\r\n sqlArray = {}\r\n sqlArray[self.deviceDescr] = {}\r\n sqlArray[self.deviceDescr][self.devNumber] = {}\r\n sqlArray[self.deviceDescr][self.devNumber][\"General\"] = result\r\n sqlArray[self.deviceDescr][self.devNumber][\"_ExtractInfo\"] = {}\r\n sqlArray[self.deviceDescr][self.devNumber][\"_ExtractInfo\"][\"ExtractTime\"] = time.time()\r\n sqlArray[\"ReadError\"] = False \r\n return sqlArray\r\n \r\n except Exception as e: \r\n self.log.printError(\"ERROR in Retreiving Seatel VSAT Data,%s Module Error\" % sys._getframe().f_code.co_name) \r\n self.log.printError( str(e))\r\n self.Error = True\r\n Extra[\"ReadError\"] = True\r\n return Extra\r\n else:\r\n self.log.printWarning(\"%s skipped due to previous failure\" % sys._getframe().f_code.co_name)\r\n return None","def getAll(self):\n # Get VT\n self.getVT()\n # Process VT data\n self.processVT()\n # Get reverse DNS\n self.getRDNS()\n # Get passivetotal\n self.getPT()\n # Get Geolocation\n self.getGeo()\n # Get Shodan\n self.getShodan()","def get_all_data(self):\n\t\ttemp = self.get_temp()\n\t\taccel = self.get_accel_data()\n\t\tgyro = self.get_gyro_data()\n\t\treturn [accel, gyro, temp]","def get_enriched_user_raw_data(self):\n _items_of_scenario = DataEnrichmentScenarioItem.objects.filter(scenario=self.scenario).order_by('order')\n for _enhancement_item in _items_of_scenario:\n _worker_model = _enhancement_item.worker\n _worker_instance = None # Stays None until first needed\n\n for _type in range(len(RawData.DATA_TYPE)):\n if len(self.raw_data_groups[_type]) > 0: # If there is data for this type\n if not _worker_model.applicable_to or _worker_model.applicable_to == _type: # Whether worker is applicable to every type, or this type\n if not _worker_instance:\n _worker_instance = DataEnrichManager._instantiate_enrich_worker(_worker_model.worker_name)\n _results = _worker_instance.enrich(self.raw_data_groups[_type], _type, _worker_model.compatible_with.all()) # Base class'es enrich function delegates the call to right function according to _type parameter\n # Also sending the compatible providers, so it won't process them\n if not _results:\n continue\n for i in range(len(_results)):\n if _results[i] is not None: # If the worker processed this item\n self.enriched_data_groups[_type][i].criteria.append(_worker_model.name)\n self.enriched_data_groups[_type][i].multiplier.append(_enhancement_item.multiplier)\n self.enriched_data_groups[_type][i].priority.append(_results[i])\n\n Log.debug('Enrich results: ' + str(self.enriched_data_groups))\n for _layer in self.enriched_data_groups: # Merging layers of enrichment results\n for _item in _layer:\n _weight = sum(_item.multiplier)\n if _weight > 0:\n _weight += 0.0 # To make float division\n _total = 0\n if type(_item.priority) == float:\n _total = _item.priority\n else:\n for i, _score in enumerate(_item.priority): # To calculate weighted priority (i.e. if total weight was 50 and total score was 35, then score will be 70)\n _total += _score * (_item.multiplier[i] / _weight)\n\n _item.priority = _total\n _item.criteria = ','.join(_item.criteria)\n else: # There wasn't any enrichment for this data\n _item.priority = 0\n _item.criteria = 'No matching criteria'\n return self._sort_by_priority()","def get_video_data(self):\n\t\tfeature_str = 'fdhh' if self.fdhh else 'pca'\n\t\tif self.options.mode == 'test':\n\t\t\tfeature_path = (f'{self.feature_folder}_FD', f'train_test_{feature_str}.pic')\n\t\telse:\n\t\t\tfeature_path = (f'{self.feature_folder}_FD', f'train_dev_{feature_str}.pic')\n\t\t\t\n\t\t# Return saved features if exist:\n\t\tif not self.options.save_features and os.path.exists(f'{feature_path[0]}/{feature_path[1]}'):\n\t\t\tX_train, X_test = load_from_file(f'{feature_path[0]}/{feature_path[1]}')\n\t\telse:\n\t\t\tX_train, X_test = self.get_train_test()\n\t\t\t'''X_train, X_test = scale(X_train, X_test, scale_type='standard', axis=0, use_boxcox=True, boxcox_axis=0,\n\t\t\t use_pandas=True, verbose=self.options.verbose)'''\n\t\t\tX_train, X_test = scale(X_train, X_test, scale_type='minmax', axis=0, use_pandas=True,\n\t\t\t verbose=self.options.verbose)\n\t\t\tif self.fdhh:\n\t\t\t\tif self.options.verbose:\n\t\t\t\t\tprint('Performing FDHH over train and test set...')\n\t\t\t\tX_train = X_train.groupby(level=0).apply(self.FDHH)\n\t\t\t\tX_test = X_test.groupby(level=0).apply(self.FDHH)\n\t\t\t\tif self.options.verbose:\n\t\t\t\t\tprint(f'Sparsity in Train fdhh = {np.sum(X_train.values == 0) / X_train.size}')\n\t\t\t\t\tprint(f'Sparsity in Test fdhh = {np.sum(X_test.values == 0) / X_test.size}')\n\t\t\telse:\n\t\t\t\tX_train, X_test = self.video_pca(X_train, X_test)\n\t\t\t\t\n\t\tif self.options.save_features:\n\t\t\tsave_to_file(feature_path[0], feature_path[1], (X_train, X_test))\n\t\t\tself.options.save_features = False\n\t\t\n\t\tif not self.fdhh:\n\t\t\tX_train = self.split_videos(X_train)\n\t\t\tX_test = self.split_videos(X_test)\n\t\t\t\n\t\treturn [X_train, X_test]","def getAllSpectrumMeasurements(self): \n return self.spectrum","def collect(self):\r\n for idx_ds, ds in enumerate(self.datasets):\r\n # print \"collect() using ds = \", repr(ds)\r\n reader_rows = ds.dict_reader()\r\n for row in reader_rows:\r\n # print \"Collect: idx_ds=%d\" % idx_ds\r\n for summary in self.summaries:\r\n #Derive coords from the row for this summary\r\n coords=[]\r\n for sum_col in summary.columns:\r\n level = str(row[sum_col.name])\r\n if level is not None and level != \"None\": \r\n if level.find('.') != -1:\r\n # May be a float value with .0 ending to trim\r\n try:\r\n # If value is parsable as a float, and it \r\n # is an integer, represent it as an integer.\r\n flevel = float(level)\r\n # Strip a final .0 from the string.\r\n level = (\r\n str(int(flevel)) if flevel == int(flevel)\r\n else str(level))\r\n except:\r\n # Not a float, OK.\r\n pass\r\n else:\r\n level = \"\"\r\n coords.append(level)\r\n #print \"coords:\", repr(coords)\r\n #Register row data into this summary.\r\n cell = summary.cell(coords)\r\n #Future, along with ds_index, could also pass along \r\n # row's ordinal column values.\r\n # Note to self: rename accrue_row to accrue_row() \r\n # when get into eclipse env\r\n cell.entry.accrue_row(idx_ds)","def get_data(self)->pd.DataFrame:\n pass","def samples(self):\n pass","def get_datasets_summary(rs):\n\n\tif rs == \"rs1\":\n\t\tdataset_list = db.get_engine(current_app, 'methylation_data').execute(\"SELECT * FROM datasets WHERE dataset NOT LIKE 'CEMBA_RS2_%%'\").fetchall()\n\t\tdataset_list += db.get_engine(current_app, 'snATAC_data').execute(\"SELECT * FROM datasets WHERE dataset NOT LIKE 'CEMBA_RS2_%%'\").fetchall()\n\n\t\t# This is a hack to get unique values in a list of dictionaries\n\t\tdataset_list = list({x['dataset']:x for x in dataset_list}.values());\n\t\ttotal_methylation_cell_each_dataset = db.get_engine(current_app, 'methylation_data').execute(\"SELECT dataset, COUNT(*) as `num` FROM cells WHERE dataset NOT LIKE 'CEMBA_RS2_%%' GROUP BY dataset\").fetchall()\n\t\ttotal_snATAC_cell_each_dataset = db.get_engine(current_app, 'snATAC_data').execute(\"SELECT dataset, COUNT(*) as `num` FROM cells WHERE dataset NOT LIKE 'CEMBA_RS2_%%' GROUP BY dataset\").fetchall()\n\telif rs == \"rs2\":\n\t\tdataset_list = db.get_engine(current_app, 'methylation_data').execute(\"SELECT * FROM datasets WHERE dataset LIKE 'CEMBA_RS2_%%'\").fetchall()\n\t\ttotal_methylation_cell_each_dataset = db.get_engine(current_app, 'methylation_data').execute(\"SELECT dataset, COUNT(*) as `num` FROM cells WHERE dataset LIKE 'CEMBA_RS2_%%' GROUP BY dataset\").fetchall()\n\t\ttotal_snATAC_cell_each_dataset = db.get_engine(current_app, 'snATAC_data').execute(\"SELECT dataset, COUNT(*) as `num` FROM cells WHERE dataset LIKE 'CEMBA_RS2_%%' GROUP BY dataset\").fetchall()\n\telif rs == \"all\":\n\t\tdataset_list = db.get_engine(current_app, 'methylation_data').execute(\"SELECT * FROM datasets\").fetchall()\n\t\tdataset_list += db.get_engine(current_app, 'snATAC_data').execute(\"SELECT * FROM datasets\").fetchall()\n\t\t# This is a hack to get unique values in a list of dictionaries\n\t\tdataset_list = list({x['dataset']:x for x in dataset_list}.values());\n\t\ttotal_methylation_cell_each_dataset = db.get_engine(current_app, 'methylation_data').execute(\"SELECT dataset, COUNT(*) as `num` FROM cells GROUP BY dataset\").fetchall()\n\t\ttotal_snATAC_cell_each_dataset = db.get_engine(current_app, 'snATAC_data').execute(\"SELECT dataset, COUNT(*) as `num` FROM cells GROUP BY dataset\").fetchall()\n\telse:\n\t\treturn\n\n\ttotal_methylation_cell_each_dataset = [ {d['dataset']: d['num']} for d in total_methylation_cell_each_dataset ]\n\ttotal_methylation_cell_each_dataset = { k: v for d in total_methylation_cell_each_dataset for k, v in d.items() }\n\ttotal_snATAC_cell_each_dataset = [ {d['dataset']: d['num']} for d in total_snATAC_cell_each_dataset ]\n\ttotal_snATAC_cell_each_dataset = { k: v for d in total_snATAC_cell_each_dataset for k, v in d.items() }\n\n\tdataset_cell_counts = []\n\tfor dataset in dataset_list:\n\t\ttry:\n\t\t\tnum_snATAC_cells = total_snATAC_cell_each_dataset[dataset['dataset']]\n\t\texcept KeyError as e:\n\t\t\tnum_snATAC_cells = 0\n\n\t\tif \"RS2\" not in dataset['dataset']:\n\t\t\tbrain_region_code = dataset['dataset'].split('_')[1]\n\t\t\tresearch_segment = \"RS1\"\n\t\telse:\n\t\t\tbrain_region_code = dataset['dataset'].split('_')[2]\n\t\t\tbrain_region_code = brain_region_code[-2:]\n\t\t\tresearch_segment = \"RS2\"\n\n\t\tregions_sql = db.get_engine(current_app, 'methylation_data').execute(\"SELECT ABA_description FROM ABA_regions WHERE ABA_acronym='%s'\" % dataset['brain_region']).fetchone()\n\t\tif regions_sql is not None:\n\t\t\tABA_regions_descriptive = regions_sql['ABA_description'].replace('+', ', ')\n\t\telse:\n\t\t\tABA_regions_descriptive = \"\"\n\n\t\tif rs == \"rs1\":\n\t\t\ttry:\n\t\t\t\tdataset_cell_counts.append( {\"dataset_name\": dataset['dataset'],\n\t\t\t\t\t\t\t\t\t\t\t \"sex\": dataset['sex'],\n\t\t\t\t\t\t\t\t\t\t\t \"methylation_cell_count\": total_methylation_cell_each_dataset[dataset['dataset']],\n\t\t\t\t\t\t\t\t\t\t\t \"snATAC_cell_count\": num_snATAC_cells,\n\t\t\t\t\t\t\t\t\t\t\t \"ABA_regions_acronym\": dataset['brain_region'].replace('+', ', '),\n\t\t\t\t\t\t\t\t\t\t\t \"ABA_regions_descriptive\": ABA_regions_descriptive,\n\t\t\t\t\t\t\t\t\t\t\t \"slice\": brain_region_code,\n\t\t\t\t\t\t\t\t\t\t\t \"date_added\": str(dataset['date_online']),\n\t\t\t\t\t\t\t\t\t\t\t \"description\": dataset['description'] })\n\t\t\texcept:\n\t\t\t\tdataset_cell_counts.append( {\"dataset_name\": dataset['dataset'],\n\t\t\t\t\t\t\t\t\t\t\t \"sex\": dataset['sex'],\n\t\t\t\t\t\t\t\t\t\t\t \"methylation_cell_count\": 0,\n\t\t\t\t\t\t\t\t\t\t\t \"snATAC_cell_count\": num_snATAC_cells,\n\t\t\t\t\t\t\t\t\t\t\t \"ABA_regions_acronym\": dataset['brain_region'].replace('+', ', '),\n\t\t\t\t\t\t\t\t\t\t\t \"ABA_regions_descriptive\": ABA_regions_descriptive,\n\t\t\t\t\t\t\t\t\t\t\t \"slice\": brain_region_code,\n\t\t\t\t\t\t\t\t\t\t\t \"date_added\": str(dataset['date_online']),\n\t\t\t\t\t\t\t\t\t\t\t \"description\": dataset['description'] })\n\t\telse:\n\t\t\ttarget_region_sql = db.get_engine(current_app, 'methylation_data').execute(\"SELECT ABA_description FROM ABA_regions WHERE ABA_acronym='%s'\" % dataset['target_region']).fetchone()\n\t\t\tif target_region_sql is not None:\n\t\t\t\ttarget_region_descriptive = target_region_sql['ABA_description'].replace('+', ', ')\n\t\t\telse:\n\t\t\t\ttarget_region_descriptive = \"\"\n\n\t\t\ttry:\n\t\t\t\tdataset_cell_counts.append( {\"dataset_name\": dataset['dataset'],\n\t\t\t\t\t\t\t\t\t\t\t \"research_segment\": research_segment,\n\t\t\t\t\t\t\t\t\t\t\t \"sex\": dataset['sex'],\n\t\t\t\t\t\t\t\t\t\t\t \"methylation_cell_count\": total_methylation_cell_each_dataset[dataset['dataset']],\n\t\t\t\t\t\t\t\t\t\t\t \"snATAC_cell_count\": num_snATAC_cells,\n\t\t\t\t\t\t\t\t\t\t\t \"ABA_regions_acronym\": dataset['brain_region'].replace('+', ', '),\n\t\t\t\t\t\t\t\t\t\t\t \"ABA_regions_descriptive\": ABA_regions_descriptive,\n\t\t\t\t\t\t\t\t\t\t\t \"slice\": brain_region_code,\n\t\t\t\t\t\t\t\t\t\t\t \"date_added\": str(dataset['date_online']),\n\t\t\t\t\t\t\t\t\t\t\t \"description\": dataset['description'],\n\t\t\t\t\t\t\t\t\t\t\t \"target_region_acronym\": dataset['target_region'],\n\t\t\t\t\t\t\t\t\t\t\t \"target_region_descriptive\": target_region_descriptive})\n\t\t\texcept:\n\t\t\t\tdataset_cell_counts.append( {\"dataset_name\": dataset['dataset'],\n\t\t\t\t\t\t\t\t\t\t\t \"research_segment\": research_segment,\n\t\t\t\t\t\t\t\t\t\t\t \"sex\": dataset['sex'],\n\t\t\t\t\t\t\t\t\t\t\t \"methylation_cell_count\": 0,\n\t\t\t\t\t\t\t\t\t\t\t \"snATAC_cell_count\": num_snATAC_cells,\n\t\t\t\t\t\t\t\t\t\t\t \"ABA_regions_acronym\": dataset['brain_region'].replace('+', ', '),\n\t\t\t\t\t\t\t\t\t\t\t \"ABA_regions_descriptive\": ABA_regions_descriptive,\n\t\t\t\t\t\t\t\t\t\t\t \"slice\": brain_region_code,\n\t\t\t\t\t\t\t\t\t\t\t \"date_added\": str(dataset['date_online']),\n\t\t\t\t\t\t\t\t\t\t\t \"description\": dataset['description'],\n\t\t\t\t\t\t\t\t\t\t\t \"target_region_acronym\": dataset['target_region'],\n\t\t\t\t\t\t\t\t\t\t\t \"target_region_descriptive\": target_region_descriptive})\n\n\treturn json.dumps(dataset_cell_counts)","def explore_data():\n labels = [\"vehicles\", \"non-vehicles\"]\n labelmap = {0: \"vehicles\", 1: \"non-vehicles\"}\n vehicles_glob = os.path.join(data_dir, \"vehicles\", \"**\", \"*.png\")\n nonvehicles_glob = os.path.join(data_dir, \"non-vehicles\", \"**\", \"*.png\")\n class_fnames = [\n glob.glob(vehicles_glob, recursive = True),\n glob.glob(nonvehicles_glob, recursive = True)]\n n_samples = [len(fnames) for fnames in class_fnames]\n shapes = []\n samples = []\n print(table_format([\"label\", \"size\", \"shape\"], header = True))\n for label, fnames in enumerate(class_fnames):\n indices = np.random.choice(len(fnames), 4*10, replace = False)\n for i in indices:\n fname = fnames[i]\n img = cv2.imread(fname)\n samples.append(img)\n shape = img.shape\n shapes.append(shape)\n print(table_format([labels[label], n_samples[label], shapes[label]]))\n\n samples = np.stack(samples)\n samples = tile(samples, 2*4, 10)\n cv2.imwrite(os.path.join(out_dir, \"datasamples.png\"), samples)\n\n return class_fnames, labelmap","def _datasets(self):\n return self._flat_data._datasets","def get_datasets(load_key=None, maven=False):\n ds_names = {}\n if load_key == 'R2349': \n ds_names['batsrus_mf_lr'] = model_dir+'R2349/batsrus_3d_multi_fluid_lowres.h5'\n ds_names['batsrus_multi_species'] = model_dir+'R2349/batsrus_3d_multi_species.h5'\n ds_names['batsrus_electron_pressure'] = model_dir+'R2349/batsrus_3d_pe.h5'\n ds_names['heliosares'] ='/Volumes/triton/Data/ModelChallenge/R2349/heliosares_multi.h5'\n #ds_names['rhybrid'] ='/Volumes/triton/Data/ModelChallenge/R2349/rhybrid.h5'\n \n ds_types = {'batsrus1':[key for key in ds_names.keys() if 'multi_fluid' in key],\n 'batsrus2':[key for key in ds_names.keys() if 'multi_species' in key],\n 'batsrus3':[key for key in ds_names.keys() if 'electron_pressure' in key],\n 'batsrus4':[key for key in ds_names.keys() if 'mf_lr' in key],\n 'heliosares':[key for key in ds_names.keys() if 'helio' in key],\n 'rhybrid_helio':[key for key in ds_names.keys() if 'rhybrid' in key ]}\n if maven or True:\n ds_names['maven']=orbit_dir+'orbit_2349.csv'\n #ds_names['maven'] = orbit_dir+'orbit_plume_2349.csv'\n ds_types['maven']=['maven']\n elif load_key == 'batsrus_mf_lowres':\n ds_names['batsrus_mf_lr'] = model_dir+'R2349/batsrus_3d_multi_fluid_lowres.h5'\n ds_types = {'batsrus_mf_lr' : ['batsrus_mf_lr']}\n\n\n elif load_key == 'helio_multi':\n ds_names['t00550'] = model_dir+'R2349/Heliosares_Multi/t00550.h5'\n ds_names['t00560'] = model_dir+'R2349/Heliosares_Multi/t00560.h5'\n ds_names['t00570'] = model_dir+'R2349/Heliosares_Multi/t00570.h5'\n ds_names['t00580'] = model_dir+'R2349/Heliosares_Multi/t00580.h5'\n ds_names['t00590'] = model_dir+'R2349/Heliosares_Multi/t00590.h5'\n ds_names['t00600'] = model_dir+'R2349/Heliosares_Multi/t00600.h5'\n ds_names['t00610'] = model_dir+'R2349/Heliosares_Multi/t00610.h5'\n ds_names['t00620'] = model_dir+'R2349/Heliosares_Multi/t00620.h5'\n ds_names['t00630'] = model_dir+'R2349/Heliosares_Multi/t00630.h5'\n ds_names['t00640'] = model_dir+'R2349/Heliosares_Multi/t00640.h5'\n ds_names['t00650'] = model_dir+'R2349/Heliosares_Multi/t00650.h5'\n\n ds_types = {'heliosares':[key for key in ds_names.keys()]}\n if maven:\n #ds_names['maven'] = orbit_dir+'orbit_2349.csv'\n ds_types['maven']=['maven']\n elif load_key == 'SDC_BATS':\n ds_names['LS180_SSL000_max'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL000_max.h5'\n ds_names['LS270_SSL000_max'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL000_max.h5'\n ds_names['LS090_SSL000_max'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL000_max.h5'\n ds_names['LS180_SSL270_max'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL270_max.h5'\n ds_names['LS270_SSL270_max'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL270_max.h5'\n ds_names['LS090_SSL270_max'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL270_max.h5'\n ds_names['LS180_SSL180_max'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL180_max.h5'\n ds_names['LS270_SSL180_max'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL180_max.h5'\n ds_names['LS090_SSL180_max'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL180_max.h5'\n ds_names['LS180_SSL000_min'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL000_min.h5'\n ds_names['LS270_SSL000_min'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL000_min.h5'\n ds_names['LS090_SSL000_min'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL000_min.h5'\n ds_names['LS180_SSL270_min'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL270_min.h5'\n ds_names['LS270_SSL270_min'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL270_min.h5'\n ds_names['LS090_SSL270_min'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL270_min.h5'\n ds_names['LS180_SSL180_min'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL180_min.h5'\n ds_names['LS270_SSL180_min'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL180_min.h5'\n ds_names['LS090_SSL180_min'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL180_min.h5'\n\n ds_types = {'batsrus':[key for key in ds_names.keys()]}\n\n elif load_key == 'SDC_G1':\n #BATSRUS\n ds_names['bats_min_LS270_SSL0'] = \\\n model_dir+'SDC_Archive/BATSRUS/'+'3d__ful_4_n00060000_PERmin-SSLONG0.h5'\n ds_names['bats_min_LS270_SSL180'] = \\\n model_dir+'SDC_Archive/BATSRUS/'+'3d__ful_4_n00060000_PERmin-SSLONG180.h5'\n ds_names['bats_min_LS270_SSL270'] = \\\n model_dir+'SDC_Archive/BATSRUS/'+'3d__ful_4_n00060000_PERmin-SSLONG270.h5' \n \n #HELIOSARES\n #ds_names['helio_1'] = \\\n # model_dir+'SDC_Archive/HELIOSARES/Hybrid/'+'helio_1.h5'\n \n #ds_names['helio_2'] = \\\n # model_dir+'SDC_Archive/HELIOSARES/Hybrid/'+'helio_2.h5'\n \n \n ds_types = {'batsrus1':[key for key in ds_names.keys() if 'bats' in key],\n 'heliosares':[key for key in ds_names.keys() if 'helio' in key]}\n if maven:\n pass\n #ds_names['maven'] = orbit_dir+'orbit_2349.csv'\n #ds_types['maven']=['maven']\n\n elif load_key == 'rhybrid_res':\n ds_names = {'rhybrid240':'/Volumes/triton/Data/ModelChallenge/R2349/rhybrid.h5',\n 'rhybrid120':'/Volumes/triton/Data/ModelChallenge/R2349/HYB/state00030000.h5'}\n ds_types = {'rhybrid1':['rhybrid240'], 'rhybrid2':['rhybrid120']}\n elif load_key == 'batsrus_tseries':\n ds_names = {'batsrus_mf':'/Volumes/triton/Data/ModelChallenge/R2349/BATSRUS/10km_mf/3d__ful_4_n00040000.h5',\n 'batsrus_ms':'/Volumes/triton/Data/ModelChallenge/R2349/BATSRUS/10km_ms/3d__mhd_6_n0050000.h5'}\n ds_types = {'batsrus_mf':['batsrus_mf'], 'batsrus_ms':['batsrus_ms']}\n\n elif load_key == 'maven':\n ds_names, ds_types = {},{}\n ds_names['maven'] = orbit_dir+'orbit_2349.csv'\n ds_types['maven']=['maven']\n elif load_key == 'exo_2349':\n keys = ['2349_1RM_225km','2349_1RM_450km', '2349_2RM_450km',\n '2349_2RM_900km','2349_4RM_900km'] \n ds_names = {k:exo_dir+'/'+k+'/'+k+'.h5' for k in keys}\n ds_types = {k:[k] for k in keys}\n elif load_key == 'exo_comparisonA':\n keys = ['2349_1RM_225km', '2349_2RM_450km',\n '2349_1.5RM_338km'] \n ds_names = {k:exo_dir+'/ComparisonA/'+k+'.h5' for k in keys}\n ds_types = {k:[k] for k in keys}\n elif load_key == 'exo_comparisonB':\n keys = ['2349_1RM_225km', 'T0_1RM_225km', 'T1_1RM_225km', \"T2_1RM_225km\"] \n ds_names = {k:exo_dir+'/ComparisonB/'+k+'.h5' for k in keys}\n ds_types = {k:[k] for k in keys}\n\n elif load_key == 'exo_t1':\n keys = ['T1_1RM_112km', 'T1_1RM_225km', #'T1_1RM_450km',\n 'T1_2RM_225km', 'T1_2RM_450km', #'T1_2RM_900km',\n 'T1_4RM_900km']\n\n ds_names = {k:exo_dir+'/'+k+'/'+k+'.h5' for k in keys}\n ds_types = {k:[k] for k in keys}\n\n else:\n print('No datasets selected')\n \n\n return (ds_names, ds_types)","def load_data(self):","def all_experiments():\n elo_explain_experiments()\n alpha_beta_experiments()\n mtcs_experiments()","def populate_data(self):\r\n # Importing StationData with the standard imports causes a redundancy\r\n # problem, so it is imported here only when it is needed.\r\n from stationData import StationData\r\n # Find data requirements from all plumes.\r\n requirements = describe.PLUMES\r\n # Loop over plumes and define parameters to be used for pulling data.\r\n grib_file = pygrib.open(self.grib_file_path)\r\n for req in requirements:\r\n (plume,data_types,grid_level_type,grid_level,unused) = req\r\n selected = grib_file.select(shortName=data_types,\r\n typeOfLevel=grid_level_type,\r\n level=grid_level)\r\n for i, message in enumerate(selected):\r\n if i % 20 == 0:\r\n print '%s %s/%s Grib messages processed for %s' %\\\r\n (PRETEXT, i + 1, len(selected), req[0])\r\n for sdo in StationData.instances:\r\n if sdo.grib_i is None:\r\n StationData.populate_grid_information(message,\r\n self.config)\r\n sdo.add_data(plume,self.member_name,message)\r\n grib_file.close()\r\n return","def get_all(self):\n self.data = list(self.data)\n return self.data","def get_data_experimentIDAndTimePointAndUnits_dataStage02GlogNormalized(self, experiment_id_I,time_point_I,concentration_units_I):\n #Tested\n try:\n data = self.session.query(data_stage02_quantification_glogNormalized.experiment_id,\n data_stage02_quantification_glogNormalized.sample_name_short,\n data_stage02_quantification_glogNormalized.time_point,\n data_stage02_quantification_glogNormalized.component_group_name,\n data_stage02_quantification_glogNormalized.component_name,\n data_stage02_quantification_glogNormalized.calculated_concentration,\n data_stage02_quantification_glogNormalized.calculated_concentration_units).filter(\n data_stage02_quantification_glogNormalized.experiment_id.like(experiment_id_I),\n data_stage02_quantification_glogNormalized.time_point.like(time_point_I),\n data_stage02_quantification_glogNormalized.calculated_concentration_units.like(concentration_units_I),\n data_stage02_quantification_glogNormalized.used_.is_(True)).group_by(\n data_stage02_quantification_glogNormalized.experiment_id,\n data_stage02_quantification_glogNormalized.sample_name_short,\n data_stage02_quantification_glogNormalized.time_point,\n data_stage02_quantification_glogNormalized.component_group_name,\n data_stage02_quantification_glogNormalized.component_name,\n data_stage02_quantification_glogNormalized.calculated_concentration,\n data_stage02_quantification_glogNormalized.calculated_concentration_units).all();\n data_O = [];\n for d in data: \n data_1 = {};\n data_1['experiment_id'] = d.experiment_id;\n data_1['sample_name_short'] = d.sample_name_short;\n data_1['time_point'] = d.time_point;\n data_1['component_group_name'] = d.component_group_name;\n data_1['component_name'] = d.component_name;\n data_1['calculated_concentration'] = d.calculated_concentration;\n data_1['calculated_concentration_units'] = d.calculated_concentration_units;\n data_O.append(data_1);\n return data_O;\n except SQLAlchemyError as e:\n print(e);","def _extract_all(sel,\n rootpath=r'D:\\WorkStation_2018\\WorkStation_dynamicFC\\Workstation_dynamic_fc_baobaoComputer\\Data\\Dynamic',\n whichstate='state1'):\n\n # hc\n group_name = 'HC'\n data_hc = sel._extract_one(rootpath, whichstate, group_name)\n\n # mdd\n group_name = 'MDD'\n data_mdd = sel._extract_one(rootpath, whichstate, group_name)\n\n # bd\n group_name = 'BD'\n data_bd = sel._extract_one(rootpath, whichstate, group_name)\n\n # sz\n group_name = 'SZ'\n data_sz = sel._extract_one(rootpath, whichstate, group_name)\n\n # concat\n data_all = pd.concat([data_hc, data_mdd, data_bd, data_sz], axis=0)\n data_all.index = np.arange(0, np.shape(data_all)[0])\n\n return data_all","def get_data():\n\n size, intensity, age = [], [], []\n def calculate(data, data_top):\n \"\"\"Return age and the averages of size and intensity.\"\"\"\n size, intensity, age = np.array([data[\"Size\"]]), np.array([data[\"Intensity\"]]), data_top.iat[1,0]\n size_avg, intensity_avg = np.average(size), np.average(intensity)\n return size_avg, intensity_avg, age\n \n with os.scandir(\"imgdata/\") as files:\n for entry in files:\n data = pd.read_csv(entry, header=3, index_col=0)\n data_top = pd.read_csv(entry, index_col=0, nrows=2, header=None)\n result = calculate(data, data_top)\n size.append(result[0])\n intensity.append(result[1])\n age.append(result[2])\n return size, intensity, age"],"string":"[\n \"def datasets(self):\\n pass\",\n \"def getData(trainSize):\\r\\n return splitData([getReal(), getFake()], trainSize=trainSize)\",\n \"def get_raw(data_folder, dataset_id, subject, stim_type=\\\"distress\\\"):\\r\\n\\r\\n if dataset_id in [\\\"raw_clean_32\\\"]: #two conditions experiments\\r\\n raw_0, raw_1, events0, events1 = get_dataset_low_v_high(data_folder, dataset_id, subject, ShowFig=False)\\r\\n elif dataset_id in [\\\"Distress2010\\\",\\\"NormativeDB\\\",\\\"Tinnitus_EEG\\\"]:\\r\\n raw_0, raw_1, events0, events1 = get_dataset_distress(data_folder, dataset_id,\\r\\n subject, stim_type=stim_type, ShowFig=False)\\r\\n else:\\r\\n print(dataset_id + \\\": Unknown dataset, please check compatible dataset using get_dataset_list().\\\")\\r\\n print(dataset_id + \\\": if you want, you can add this dataset to get_dataset_list() and get_raw(),\\\")\\r\\n print(dataset_id + \\\": OR you can use directly load_sessions_raw() if your data respect a known structure.\\\")\\r\\n\\r\\n return raw_0, raw_1, events0, events1\",\n \"def _extract_data(self) -> np.ndarray:\\n \\n mats = Material.objects.all()\\n \\n mat_arrays = []\\n for mat in mats: # django queryset -> python list\\n mat_features = []\\n \\n # Add data\\n # Some data are missing here.\\n #TODO: Delete those if sentences after cleaning the data.\\n mat_features.append(mat.model_surface_temperature if mat.model_surface_temperature!=None else 0)\\n mat_features.append(mat.melt_temperature if mat.melt_temperature!=None else 0)\\n mat_features.append(mat.mold_temperature_range_min if mat.mold_temperature_range_min!=None else 0)\\n mat_features.append(mat.mold_temperature_range_max if mat.mold_temperature_range_max!=None else 0)\\n mat_features.append(mat.melt_temperature_range_min if mat.melt_temperature_range_min!=None else 0)\\n mat_features.append(mat.melt_temperature_range_max if mat.melt_temperature_range_max!=None else 0)\\n mat_features.append(mat.absolute_maximum_melt_temperature if mat.absolute_maximum_melt_temperature!=None else 0)\\n mat_features.append(mat.ejection_temperature if mat.ejection_temperature!=None else 0)\\n mat_features.append(mat.maximum_shear_stress if mat.maximum_shear_stress!=None else 0)\\n mat_features.append(mat.maximum_shear_rate if mat.maximum_shear_rate!=None else 0)\\n mat_features.append(mat.melt_density if mat.melt_density!=None else 0)\\n mat_features.append(mat.solid_density if mat.solid_density!=None else 0)\\n mat_features.append(mat.pvt_b5 if mat.pvt_b5!=None else 0)\\n mat_features.append(mat.pvt_b6 if mat.pvt_b6!=None else 0)\\n mat_features.append(mat.pvt_b1m if mat.pvt_b1m!=None else 0)\\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\\n mat_features.append(mat.pvt_b4m if mat.pvt_b4m!=None else 0)\\n mat_features.append(mat.pvt_b1s if mat.pvt_b1s!=None else 0)\\n mat_features.append(mat.pvt_b2s if mat.pvt_b2s!=None else 0)\\n mat_features.append(mat.pvt_b3s if mat.pvt_b3s!=None else 0)\\n mat_features.append(mat.pvt_b4s if mat.pvt_b4s!=None else 0)\\n mat_features.append(mat.pvt_b7 if mat.pvt_b7!=None else 0)\\n mat_features.append(mat.pvt_b8 if mat.pvt_b8!=None else 0)\\n mat_features.append(mat.pvt_b9 if mat.pvt_b9!=None else 0)\\n mat_features.append(mat.elastic_modulus_e1 if mat.elastic_modulus_e1!=None else 0)\\n mat_features.append(mat.elastic_modulus_e2 if mat.elastic_modulus_e2!=None else 0)\\n mat_features.append(mat.poisson_ratio_v12 if mat.poisson_ratio_v12!=None else 0)\\n mat_features.append(mat.poisson_ratio_v23 if mat.poisson_ratio_v23!=None else 0)\\n mat_features.append(mat.shear_modulus_g12 if mat.shear_modulus_g12!=None else 0.)\\n mat_features.append(mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha1 if mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha1!=None else 0.)\\n mat_features.append(mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha2 if mat.thermal_expansion_data_transverse_isotropic_coefficient_alpha2!=None else 0.)\\n mat_features.append(mat.seven_params_n if mat.seven_params_n!=None else 0.)\\n mat_features.append(mat.seven_params_Tau if mat.seven_params_Tau!=None else 0.)\\n mat_features.append(mat.seven_params_D1 if mat.seven_params_D1!=None else 0.)\\n mat_features.append(mat.seven_params_D2 if mat.seven_params_D2!=None else 0.)\\n mat_features.append(mat.seven_params_D3 if mat.seven_params_D3!=None else 0.)\\n mat_features.append(mat.seven_params_A1 if mat.seven_params_A1!=None else 0.)\\n mat_features.append(mat.seven_params_A2 if mat.seven_params_A2!=None else 0.)\\n mat_features.append(mat.c1 if mat.c1!=None else 0.)\\n mat_features.append(mat.c2 if mat.c2!=None else 0.)\\n mat_features.append(mat.conversion_temperature if mat.conversion_temperature!=None else 0.)\\n mat_features.append(mat.MFR_temperature if mat.MFR_temperature!=None else 0.)\\n mat_features.append(mat.MFR_loading if mat.MFR_loading!=None else 0.)\\n mat_features.append(mat.measured_MFR if mat.measured_MFR!=None else 0.)\\n \\n mat_arrays.append(mat_features)\\n \\n # Get numpy arrays.\\n mat_arrays = np.array(mat_arrays, dtype=np.float64)\\n \\n return mat_arrays\",\n \"def get_main_dataset(self) -> pd.DataFrame:\\n pass\",\n \"def extract_data(self):\\n values = {}\\n for injkey in self.data_sets.keys():\\n values[injkey] = {}\\n alldata = self.data_sets[injkey]\\n paramkeys = alldata['params'].keys()\\n for datakey in alldata.keys():\\n if not datakey == 'params':\\n values[injkey][datakey] = {}\\n values[injkey][datakey]['metric_val'] = {}\\n values[injkey][datakey]['metric_val']['vals'] = []\\n for paramkey in paramkeys:\\n values[injkey][datakey][paramkey] = {}\\n values[injkey][datakey][paramkey]['vals'] = []\\n trials = alldata[datakey]\\n for trial_num in trials.keys():\\n trial = trials[trial_num]\\n values[injkey][datakey]['metric_val']['vals'] \\\\\\n .append(trial['metric_val'])\\n values[injkey][datakey]['metric_val']['type'] \\\\\\n = trial['metric']\\n values[injkey][datakey]['metric_val']['units'] \\\\\\n = 'dimensionless'\\n param_vals = trial['params']\\n for param_name in param_vals.keys():\\n val, units = self.parse_pint_string(\\n pint_string=param_vals[param_name]\\n )\\n values[injkey][datakey][param_name]['vals'] \\\\\\n .append(float(val))\\n values[injkey][datakey][param_name]['units'] \\\\\\n = units\\n self.values = values\",\n \"def data_details(self):\\n\\t\\t# Obtain the full Drusen files\\n\\t\\tdata_files = glob(op.join(self.data_dir, '*'))\\n\\n\\t\\t# Obtain the data ID and total images\\n\\t\\tdata_id = [single_file.split('\\\\\\\\')[-1].split('-')[1] for single_file in data_files]\\n\\t\\tself.total_imgs = len(data_id)\\n\\t\\tself.data_id = np.unique(data_id)\\n\\t\\treturn self\",\n \"def build_data(self):\\n from desiutil.io import combine_dicts\\n # Loop on exposures\\n odict = {}\\n for qanight in self.qa_nights:\\n for qaexp in qanight.qa_exps:\\n # Get the exposure dict\\n idict = write_qa_exposure('foo', qaexp, ret_dict=True)\\n odict = combine_dicts(odict, idict)\\n # Finish\\n self.data = odict\",\n \"def _extract_imp_data(self) -> np.ndarray:\\n \\n mats = Material.objects.all()\\n \\n mat_arrays = []\\n for mat in mats: # django queryset -> python list\\n mat_features = []\\n \\n # Add data\\n # Some data are missing here.\\n #TODO: Delete those if sentences after cleaning the data.\\n mat_features.append(mat.pvt_b5 if mat.pvt_b5!=None else 0)\\n mat_features.append(mat.pvt_b6 if mat.pvt_b6!=None else 0)\\n mat_features.append(mat.pvt_b1m if mat.pvt_b1m!=None else 0)\\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\\n mat_features.append(mat.pvt_b2m if mat.pvt_b2m!=None else 0)\\n mat_features.append(mat.pvt_b4m if mat.pvt_b4m!=None else 0)\\n mat_features.append(mat.pvt_b1s if mat.pvt_b1s!=None else 0)\\n mat_features.append(mat.pvt_b2s if mat.pvt_b2s!=None else 0)\\n mat_features.append(mat.pvt_b3s if mat.pvt_b3s!=None else 0)\\n mat_features.append(mat.pvt_b4s if mat.pvt_b4s!=None else 0)\\n mat_features.append(mat.pvt_b7 if mat.pvt_b7!=None else 0)\\n mat_features.append(mat.pvt_b8 if mat.pvt_b8!=None else 0)\\n mat_features.append(mat.pvt_b9 if mat.pvt_b9!=None else 0)\\n mat_features.append(mat.seven_params_n if mat.seven_params_n!=None else 0.)\\n mat_features.append(mat.seven_params_Tau if mat.seven_params_Tau!=None else 0.)\\n mat_features.append(mat.seven_params_D1 if mat.seven_params_D1!=None else 0.)\\n mat_features.append(mat.seven_params_D2 if mat.seven_params_D2!=None else 0.)\\n mat_features.append(mat.seven_params_D3 if mat.seven_params_D3!=None else 0.)\\n mat_features.append(mat.seven_params_A1 if mat.seven_params_A1!=None else 0.)\\n mat_features.append(mat.seven_params_A2 if mat.seven_params_A2!=None else 0.)\\n \\n mat_arrays.append(mat_features)\\n \\n # Get numpy arrays.\\n mat_arrays = np.array(mat_arrays, dtype=np.float64)\\n \\n return mat_arrays\",\n \"def get_data(self):\\n if self.random_seeds: \\n self._validate_random_seeds()\\n seed_iter = list(map(iter,self.random_seeds))\\n nsamples = len(self.random_seeds[0])\\n else:\\n seed_iter = None\\n nsamples = self.numsamples\\n self._set_meta_features()\\n for _ in tqdm(range(nsamples)):\\n self._update_meta_features(seed_iter)\\n self._sample()\\n yield self._extract_features()\",\n \"def collect_experiment_data(self, dedupe=False):\\n data = {}\\n\\n for exp in self.experiments.values():\\n expdir = os.path.join(self.datadir, exp.name)\\n goals = sorted(\\n [goal\\n for goal, experiments in self.experiments_by_goal.items()\\n if exp in experiments])\\n data[exp.name] = {'goals': goals, 'variants': {}}\\n\\n for variant in exp.variants:\\n path = partial(os.path.join, expdir, variant)\\n if dedupe:\\n trial_identities = get_identities(path('__all__'))\\n trialc = len(trial_identities)\\n else:\\n trialc = count_entries(path('__all__'), dedupe=False)\\n data[exp.name]['variants'][variant] = vdata = {'trials': trialc, 'goals': {}}\\n\\n for goal in goals:\\n vdata['goals'][goal] = goaldata = {}\\n if dedupe:\\n conv_identities = trial_identities.intersection(\\n get_identities(path(goal)))\\n convc = len(conv_identities)\\n else:\\n convc = count_entries(path(goal), dedupe=False)\\n goaldata['conversions'] = convc\\n goaldata['rate'] = (float(convc) / trialc\\n if trialc\\n else float('nan'))\\n return data\",\n \"def _get_data(self):\\n project_name, experiment_id = self.parent._get_parent_identifiers()\\n\\n self._data = self.repository.get_dataframe_data(\\n project_name, self.id, experiment_id=experiment_id\\n )\",\n \"def load_own_data():\\n data = Data()\\n features = data.read_selected_features()\\n dataframe = data.get_dataframe_with(features)\\n return normalize(dataframe.values)\",\n \"def get_data_and_model_samples(self):\\n model_samples = (\\n self.net_.sample_fantasy(\\n x=self.model_samples_[-1],\\n num_mc_steps=self.num_sample_mc_steps,\\n beta=self.sample_beta,\\n mc_dynamics=self.sampler,\\n )\\n .detach()\\n .cpu()\\n .numpy()\\n )\\n data_sample_ixs = torch.randint(\\n 0, self.samples.shape[0], size=(model_samples.shape[0],)\\n )\\n data_samples = self.samples[data_sample_ixs, ...]\\n return data_samples, model_samples\",\n \"def collect_datset(self):\\n response = requests.get(self.url)\\n lines = response.text.splitlines()\\n data = []\\n for item in lines:\\n item = item.split(\\\",\\\")\\n data.append(item)\\n data.pop(0) # to remove labels from list\\n dataset = np.matrix(data)\\n return dataset\",\n \"def build_data_set(self):\\n if not self.assert_data_correct():\\n self.download_all_data()\\n self.unpack_rename_data()\\n self.split_data_characters()\\n self.clean_data_fragments()\\n self.create_font_data()\\n if not self.assert_train_augmented():\\n self.augment_train_data()\\n if not self.assert_style_data_correct():\\n self.download_style_data()\\n self.unpack_rename_data()\",\n \"def get_data(self): \\n self.improvement = []\\n self.corrsq = []\\n for filename in onlyfiles:\\n mst = MST(filename, mypath=mypath)\\n mst.estimate_correct_seqences()\\n mst.estimate_improvement()\\n self.mst.append(mst)\\n\\n self.corrsq.append(mst.corrsq)\\n self.improvement.append(mst.improvement)\\n\\n\\n\\n print(f\\\"cor = {improvement}\\\")\\n print(f\\\"improvement = {improvement}\\\")\\n print(f\\\"mittelwert der improvement = {np.mean(improvement)}\\\")\\n print(f\\\"Standardabweichung der lersteigung = {np.std(improvement)}\\\")\",\n \"def data(self):\\n return {\\\"estimate\\\":self.get_estimate(),\\n \\\"samplers\\\":self.samplers}\",\n \"def datasets(self):\\n return [Dataset.GWAS_CATALOG, Dataset.CLINVAR, Dataset.EFO]\",\n \"def get_data(self):\",\n \"def get_data():\\n wga_df = pd.read_csv(os.path.join(MODEL_DIR, 'wga/sculptures/wga_sculpture_periods.csv'), index_col=0)\\n wikiart_df = pd.read_csv(os.path.join(MODEL_DIR, 'wikiart/sculptures/wikiart_sculpture_periods.csv'), index_col=0)\\n nga_df = pd.read_csv(os.path.join(MODEL_DIR, 'nga/sculptures/nga_sculpture_periods.csv'), index_col=0)\\n\\n ######## Fix name for WGA and WikiaRt ###########\\n wga_df['Author'] = wga_df.apply(lambda x: fix_name_wga(x['Author']), axis=1)\\n wikiart_df['Author'] = wikiart_df.apply(lambda x: fix_name_wiki(x['Author']), axis=1)\\n nga_df['Author'] = nga_df.apply(lambda x: fix_name_nga(x['Author']), axis=1)\\n\\n df = pd.concat([wga_df, wikiart_df, nga_df], ignore_index=True, sort=True)\\n\\n df['Author_Fixed'] = df.apply(lambda x: fix_text(x['Author']), axis=1)\\n df['title_fixed'] = df.apply(lambda x: fix_text(x['title']), axis=1)\\n\\n periods = [\\\"BAROQUE\\\", \\\"EARLY RENAISSANCE\\\", \\\"MEDIEVAL\\\", \\\"NEOCLASSICISM\\\", \\\"HIGH RENAISSANCE\\\", \\\"MINIMALISM\\\", \\\"REALISM\\\",\\n \\\"IMPRESSIONISM\\\", \\\"ROCOCO\\\", \\\"SURREALISM\\\", \\\"MANNERISM\\\", \\\"ROMANTICISM\\\",\\n ]\\n df['Period'] = df.apply(lambda row: row['Period'].upper(), axis=1)\\n\\n # Get Desired Periods\\n df['Period'] = df.apply(lambda x: \\\"SURREALISM\\\" if \\\"SURREALISM\\\" in x['Period'] else x['Period'], axis=1)\\n df = df[(df['Period'].isin(periods))]\\n df = df.sort_values(['Author_Fixed', 'title_fixed'])\\n\\n #print(\\\"Combined Drop Rows:\\\", df.shape[0] - df.drop_duplicates(subset=['Author_Fixed', 'title_fixed']).shape[0])\\n\\n df = df.drop_duplicates(subset=['Author_Fixed', 'title_fixed'], keep='last')\\n\\n # Drop Duplicate Sculptures\\n df = df[~df['file'].isin(DUP_SCULPTURES)].reset_index(drop=True)\\n\\n #print(df['Period'].value_counts())\\n\\n return df\",\n \"def get_new_modelling_data():\\n # get latest epidemic data from OWID \\n\\n df = pd.read_json(requests.get(\\\"https://covid.ourworldindata.org/data/owid-covid-data.json\\\").content)\\n data = pd.DataFrame(df[\\\"POL\\\"][\\\"data\\\"])\\n\\n # get latest government restriction data from Oxford tracker\\n response = requests.get(\\\"https://raw.githubusercontent.com/OxCGRT/covid-policy-tracker/master/data/OxCGRT_latest.csv\\\").content\\n rest = pd.read_csv(io.StringIO(response.decode('utf-8')))\\n rest = rest[rest.CountryName == \\\"Poland\\\"]\\n\\n modelling = pd.DataFrame(Mobility.objects.values())\\n prepare_model_data(data,rest,modelling)\",\n \"def reduce_data(self, ctx):\\n self.baselines_type = ctx.get(\\\"baselines_type\\\")\\n visibilities = ctx.get(\\\"visibilities\\\")\\n p_signal = self.compute_power(visibilities)\\n\\n # Remember that the results of \\\"simulate\\\" can be used in two places: (i) the computeLikelihood method, and (ii)\\n # as data saved to file. In case of the latter, it is useful to save extra variables to the dictionary to be\\n # looked at for diagnosis, even though they are not required in computeLikelihood().\\n return [dict(p_signal=p_signal, baselines=self.baselines, frequencies=self.frequencies,\\n u=self.u, eta=self.eta)]\\n #, nbl_uv=self.nbl_uv, nbl_uvnu=self.nbl_uvnu, nbl_u=self.nbl_u, grid_weights=self.grid_weights)]\",\n \"def getAllData(self):\\r\\n return self.data\",\n \"def getMeasures():\",\n \"def build_data(self):\\n return self.mean, self.sigma\",\n \"def data(dataset=\\\"bio_eventrelated_100hz\\\"):\\n # TODO: one could further improve this function with like\\n # selectors 'ecg=True, eda=True, restingstate=True' that would\\n # find the most appropriate dataset\\n\\n dataset = dataset.lower()\\n\\n # TODO: change this path back to \\\"master\\\"\\n path = \\\"https://raw.githubusercontent.com/neuropsychology/NeuroKit/dev/data/\\\"\\n\\n # Signals as vectors =======================\\n if dataset in [\\\"eeg\\\", \\\"eeg_150hz\\\", \\\"eeg.txt\\\"]:\\n return pd.read_csv(path + \\\"eeg.txt\\\").values[:, 0]\\n\\n if dataset in [\\\"rsp\\\", \\\"rsp_1000hz\\\", \\\"rsp_1000hz.txt\\\"]:\\n return pd.read_csv(path + \\\"rsp_1000hz.txt\\\", header=None).values[:, 0]\\n\\n if dataset in [\\\"ecg\\\", \\\"ecg_1000hz\\\", \\\"ecg_1000hz.csv\\\"]:\\n return pd.read_csv(path + \\\"ecg_1000hz.csv\\\")[\\\"ECG\\\"].values\\n\\n if dataset in [\\\"ecg_3000hz\\\", \\\"ecg_3000hz.csv\\\"]:\\n return pd.read_csv(path + \\\"ecg_1000hz.csv\\\")[\\\"ECG\\\"].values\\n\\n if dataset in [\\\"eog\\\", \\\"veog\\\", \\\"eog_100hz\\\", \\\"eog_100hz.csv\\\"]:\\n return pd.read_csv(path + \\\"eog_100hz.csv\\\")[\\\"vEOG\\\"].values\\n\\n # Dataframes ===============================\\n if dataset == \\\"iris\\\":\\n info = sklearn_datasets.load_iris()\\n data = pd.DataFrame(\\n info.data, columns=[\\\"Sepal.Length\\\", \\\"Sepal.Width\\\", \\\"Petal.Length\\\", \\\"Petal.Width\\\"]\\n )\\n data[\\\"Species\\\"] = info.target_names[info.target]\\n return data\\n\\n if dataset in [\\\"eogs\\\", \\\"eogs_200hz\\\", \\\"eog_200hz\\\", \\\"eog_200hz.csv\\\"]:\\n return pd.read_csv(path + \\\"eog_200hz.csv\\\")\\n\\n # Add extension\\n if dataset in [\\\"bio_resting_8min_200hz\\\"]:\\n dataset += \\\".json\\\"\\n\\n # Specific case for json file\\n if dataset.endswith(\\\".json\\\"):\\n if \\\"https\\\" not in dataset:\\n data = pd.read_json(path + dataset, orient=\\\"index\\\")\\n else:\\n data = pd.read_json(dataset, orient=\\\"index\\\")\\n df = {}\\n for participant, row in data.iterrows():\\n for _, data_string in row.items():\\n data_list = json.loads(data_string)\\n data_pd = pd.DataFrame(data_list)\\n df[participant] = data_pd\\n\\n return df\\n\\n # TODO: Add more EEG (fif and edf datasets)\\n if dataset in [\\\"eeg_1min_200hz\\\"]:\\n\\n return pickle.load(\\n urllib.request.urlopen(\\n \\\"https://github.com/neuropsychology/NeuroKit/blob/dev/data/eeg_1min_200hz.pickle?raw=true\\\"\\n )\\n )\\n\\n # General case\\n file, ext = os.path.splitext(dataset) # pylint: disable=unused-variable\\n if ext == \\\"\\\":\\n df = pd.read_csv(path + dataset + \\\".csv\\\")\\n else:\\n if \\\"https\\\" not in dataset:\\n df = pd.read_csv(path + dataset)\\n else:\\n df = pd.read_csv(dataset)\\n return df\",\n \"def get_data():\\r\\n spatial_expmat = np.load('/home/anniegao/spatial_magan/data/spatial_pca_with_coords.npz')['arr_0']\\r\\n spatial_expmat[:,100:] *= 5\\r\\n rna_expmat = np.load('/home/anniegao/spatial_magan/data/rna_pca_sampled.npz')['arr_0']\\r\\n spatial_pca_components = np.load('/home/anniegao/spatial_magan/data/spatial_pca_100components.npz')['arr_0']\\r\\n rna_pca_components = np.load('/home/anniegao/spatial_magan/data/rna_pca_100components.npz')['arr_0']\\r\\n spatial_cluster_labels = np.load('/home/anniegao/spatial_magan/data/spatial_cluster_3_labels_phate.npz')['arr_0']\\r\\n rna_cluster_labels = np.load('/home/anniegao/spatial_magan/data/rna_cluster_5_labels_sampled.npz')['arr_0']\\r\\n return spatial_expmat, rna_expmat, spatial_pca_components, rna_pca_components, spatial_cluster_labels, rna_cluster_labels\",\n \"def _get_data(self, species_id, fit_id):\\n return self.raw_results[fit_id][species_id]\",\n \"def getCurentData(self):\\n if not self.labExperiment:\\n super().getCurentData()\\n else:\\n return np.array(self.connection.query('get_actuator_data'))\",\n \"def create_subexperiments(self):\\n subexperiments = {}\\n for label, df in self.design.groupby(level=0):\\n subexperiments[label] = SubExperiment(label, df.loc[label], self.root)\\n return subexperiments\",\n \"def _build_datasets(self):\\n self._build_datasets_sis3302()\\n self._build_datasets_sis3305()\",\n \"def data(self):\\n # Regenerate the extra data\\n if self._req_update_fill:\\n self._generate_fill()\\n if self._req_update_variation:\\n self._generate_variations()\\n\\n output = self._data_words\\n\\n # Add variations\\n where = np.where(output == '')\\n output[where] = self._data_variations[where]\\n\\n # Add fill\\n where = np.where(output == '')\\n output[where] = self._data_fill.reshape(self.shape)[where]\\n\\n return output\",\n \"def get_data_subsets(t0, t1):\\n\\n # Iridium data:\\n irid = iridium[(iridium.time >= t0) & (iridium.time <= t1)]\\n irid_B = np.vstack((irid.B_e.values, irid.B_n.values, irid.B_r.values))\\n irid_coords = np.vstack((irid.lon.values, irid.lat.values, irid.r.values))\\n\\n # SuperMAG data:\\n smag = supermag.loc[t0:t1, :]\\n smag_B = np.vstack((smag.Be.values, smag.Bn.values, smag.Bu.values))\\n smag_coords = np.vstack((smag.lon.values, smag.lat.values))\\n\\n # SuperDARN data:\\n sd = superdarn.loc[t0:t1, :]\\n vlos = sd['vlos'].values\\n sd_coords = np.vstack((sd['glon'].values, sd['glat'].values))\\n los = np.vstack((sd['le'].values, sd['ln'].values))\\n\\n\\n # Make the data objects. The scale keyword determines a weight for the dataset. Increase it to reduce weight\\n iridium_data = lompe.Data(irid_B * 1e-9, irid_coords, datatype = 'space_mag_fac', scale = 200e-9)\\n supermag_data = lompe.Data(smag_B * 1e-9, smag_coords, datatype = 'ground_mag' , scale = 100e-9)\\n superdarn_data = lompe.Data(vlos , sd_coords , LOS = los, datatype = 'convection' , scale = 500 )\\n\\n return(iridium_data, supermag_data, superdarn_data)\",\n \"def get_dataitems_for_experiment(self, id):\\n experiment = Experiment.get(id)\\n dataitems = []\\n for expgroup in experiment.experimentgroups:\\n dataitems.extend(self.get_dataitems_for_experimentgroup(expgroup.id))\\n return dataitems\",\n \"def get_data(self):\\n\\n self.read_expression()\\n self.read_tfs()\\n self.read_metadata()\\n self.set_gold_standard_and_priors()\",\n \"def Test_data():\\n print (\\\"loading test data ...\\\")\\n time_start = time.time()\\n data_root = '/media/keziwen/86AA9651AA963E1D'\\n\\n with h5py.File(join(data_root, './data/test_real2.h5')) as f:\\n test_real = f['test_real'][:]\\n with h5py.File(join(data_root, './data/test_imag2.h5')) as f:\\n test_imag = f['test_imag'][:]\\n test_real = np.transpose(test_real, (0, 1, 3, 2))\\n test_imag = np.transpose(test_imag, (0, 1, 3, 2))\\n test_data = test_real+1j*test_imag\\n time_end = time.time()\\n print ('dataset has been created using {}s'.format(time_end - time_start))\\n return test_data\",\n \"def get_data():\\n pass\",\n \"def fill_dataset(self):\\n rm, rstd = self.get_rolling_stats()\\n\\n self.add_rolling_mean(rm)\\n self.add_bollinger_bands(rstd)\\n self.add_spy_info()\\n self.add_beta_and_sharpe()\\n self.add_stlouis_data()\",\n \"def main(self):\\n\\n assault_mech_df = self.get_mech_df(url=self.assault_url)\\n heavy_mech_df = self.get_mech_df(url=self.heavy_url)\\n medium_mech_df = self.get_mech_df(url=self.medium_url)\\n light_mech_df = self.get_mech_df(url=self.light_url)\\n all_weights_df = pd.concat([assault_mech_df, heavy_mech_df, medium_mech_df, \\n light_mech_df])\\n\\n self.save_data(assault_mech_df, \\\"assault\\\")\\n self.save_data(heavy_mech_df, \\\"heavy\\\")\\n self.save_data(medium_mech_df, \\\"medium\\\")\\n self.save_data(light_mech_df, \\\"light\\\")\\n self.save_data(all_weights_df, \\\"all_weights\\\")\\n #get maximum new columns needed for splitting variants\\n max_cols = all_weights_df.variants.apply(lambda x: len(x)).max()\\n melt_cols = []\\n\\n for i in range(max_cols):\\n all_weights_df[\\\"var_\\\"+str(i)] = \\\"\\\"\\n melt_cols.append(\\\"var_\\\"+str(i))\\n\\n variant_weights_df = pd.DataFrame()\\n for index, row in all_weights_df.iterrows():\\n for i in range(len(row[\\\"variants\\\"])):\\n #add each variant to variant weights as a row with mech, tonnage, variant\\n new_row_dict = {\\n \\\"mech_name\\\":row[\\\"mechs\\\"],\\n \\\"tonnage\\\":row[\\\"tonnage\\\"],\\n \\\"variant\\\":row[\\\"variants\\\"][i].upper()\\n }\\n new_row_df = pd.DataFrame(new_row_dict, index=[0])\\n variant_weights_df = pd.concat([variant_weights_df, new_row_df])\\n\\n for i in range(len(row[\\\"hero_chassis\\\"])):\\n new_row_dict = {\\n \\\"mech_name\\\":row[\\\"hero_names\\\"],\\n \\\"tonnage\\\":row[\\\"tonnage\\\"],\\n \\\"variant\\\":row[\\\"hero_chassis\\\"][i].upper()\\n }\\n new_row_df = pd.DataFrame(new_row_dict, index=[0])\\n variant_weights_df = pd.concat([variant_weights_df, new_row_df])\\n\\n\\n for i in range(len(row[\\\"special_variants\\\"])):\\n new_row_dict = {\\n \\\"mech_name\\\":row[\\\"mechs\\\"],\\n \\\"tonnage\\\":row[\\\"tonnage\\\"],\\n \\\"variant\\\":row[\\\"special_variants\\\"][i].upper()\\n }\\n new_row_df = pd.DataFrame(new_row_dict, index=[0])\\n variant_weights_df = pd.concat([variant_weights_df, new_row_df]) \\n\\n #add champion variants by matching on \\n for i in range(len(row[\\\"champion_variants\\\"])):\\n new_row_dict = {\\n \\\"mech_name\\\":row[\\\"mechs\\\"],\\n \\\"tonnage\\\":row[\\\"tonnage\\\"],\\n \\\"variant\\\":row[\\\"champion_variants\\\"][i].upper()\\n }\\n new_row_df = pd.DataFrame(new_row_dict, index=[0])\\n variant_weights_df = pd.concat([variant_weights_df, new_row_df])\\n #remove duplicate rows \\n variant_weights_df = variant_weights_df[variant_weights_df.duplicated(keep=\\\"first\\\")==False]\\n self.save_data(variant_weights_df, \\\"variant_weights\\\")\",\n \"def all_data(self):\\n return pd.concat([self.historic_data, self.dayahead_data])\",\n \"def get_raw_data(self, dataset):\\n\\t\\tprint(\\\"Getting raw data for\\\", dataset)\\n\\t\\tself.fetched[dataset] = fetch_20newsgroups(remove = ('headers', 'footers', 'quotes'), subset = dataset)\\n\\t\\tself.raw_documents[dataset] = self.fetched[dataset].data\\n\\t\\tself.Y[dataset] = self.fetched[dataset].target\",\n \"def collect_data():\\n\\n \\\"Aqui va el codigo de alberto para recoger los datos que puede venir en forma de diccionario\\\"\\n #TODO: Función para recoger los datos de los bms y meterlos en diccionarios (Alberto jr.)\\n\\n bms1 = dict()\\n bms2 = dict()\\n bms3 = dict()\\n general = dict()\\n\\n\\n # Ejemplos de datos para meter en los diccionarios\\n\\n temperature = 35.5\\n voltage1 = 15.2\\n voltage2 = 14.8\\n date = time.strftime(\\\"%Y-%m-%d\\\") # Current date\\n t = time.strftime(\\\"%H:%M:%S\\\") # Current time\\n\\n return bms1, bms2, bms3, general\",\n \"def read_dataset_v1():\\n path = load_config()\\n T = feather.read_dataframe(path['data_dir'] / 'T_dat.feather')\\n E = feather.read_dataframe(path['data_dir'] / 'E_dat.feather')\\n M = feather.read_dataframe(path['data_dir'] / 'Meta.feather')\\n data = sio.loadmat(path['data_dir'] / 'highvar_genes.mat', squeeze_me=True)\\n return T, E, M, data\",\n \"def getAllMeasurement(self): \\n return self.measurement\",\n \"def get_raw_x_data(\\n params, fold, subject_list,\\n):\\n X = []\\n\\n for subject in subject_list:\\n rsfmri_data = load_intertva_rsfmri(\\n subject, os.path.join(params[\\\"orig_path\\\"], \\\"features_rsfMRI\\\")\\n )\\n\\n if params[\\\"modality\\\"] == \\\"gyrification\\\":\\n gyr_data = np.load(\\n os.path.join(\\n params[\\\"orig_path\\\"],\\n \\\"features_gyrification\\\",\\n \\\"{}_eig_vec_{}_onref_{}.npy\\\".format(\\n subject, params[\\\"template\\\"], params[\\\"ref_subject\\\"]\\n ),\\n )\\n )\\n x_sub_data = np.concatenate([gyr_data, rsfmri_data], axis=1)\\n elif params[\\\"modality\\\"] == \\\"tfMRI\\\":\\n tfmri_data = load_intertva_tfmri(\\n subject, os.path.join(params[\\\"orig_path\\\"], \\\"features_tfMRI\\\")\\n )\\n x_sub_data = np.concatenate([tfmri_data, rsfmri_data], axis=1)\\n X.append(x_sub_data)\\n\\n return X\\n # interTVA data has already been run on taskFMRI, on frioul\",\n \"def extract_data():\\n logging.info(f'Reading data from {impftermine.agg_export_file_name()}...')\\n df_wl = pd.read_csv(impftermine.agg_export_file_name())\\n vacc_report_file = os.path.join(credentials.vmdl_path, 'vaccination_report_bs_age_group_long.csv')\\n logging.info(f'Reading data from {vacc_report_file}...')\\n df_impf = pd.read_csv(vacc_report_file)\\n return df_wl, df_impf\",\n \"def gatherData(self):\\n dagPath, components = self.__getGeometryComponents()\\n self.gatherInfluenceWeights(dagPath, components)\\n self.gatherBlendWeights(dagPath, components)\\n\\n for attr in ['skinningMethod', 'normalizeWeights']:\\n self.data[attr] = cmds.getAttr('%s.%s' % (self.node, attr))\",\n \"def setup(self):\\n in_dataset, out_dataset = self.get_datasets()\",\n \"def setup(self):\\n in_dataset, out_dataset = self.get_datasets()\",\n \"def getdata(verbose=True, filenameext=None):\\n savepath = 'O:/Administration/02 - Økonomi og PDK/Medarbejdermapper/Kasper/Focus1 - Ad hoc opgaver/Lungemed sengedage og visitationer/plots/'\\n\\n if verbose: print(' - Getting LPR3 data from parsing SQL query for \\\"bed days\\\" ')\\n savefilename_days = savepath+'lungemedLPR3_SQLbeddays.xlsx'\\n filepath = savepath+'/../Lungemed.sql'\\n if filenameext is not None:\\n savefilename_days = savefilename_days.replace('.xlsx', filenameext+'.xlsx')\\n filepath = filepath.replace('.sql', filenameext+'.sql')\\n overwrite_days = True\\n dataframe_days = gdf.returndatapull(lbv.loadSQL_beddays(filepath=filepath), verbose=verbose, savefilename=savefilename_days, overwrite=overwrite_days)\\n\\n if verbose: print(' - Getting LPR3 data from parsing SQL query for \\\"visitations\\\" ')\\n savefilename_vis = savepath+'lungemedLPR3_SQLvisitations.xlsx'\\n filepath = savepath + '/../Lungemed_visitationsoprindelse_nogroup.sql'\\n if filenameext is not None:\\n savefilename_vis = savefilename_vis.replace('.xlsx', filenameext+'.xlsx')\\n filepath = filepath.replace('.sql', filenameext + '.sql')\\n overwrite_vis = True\\n dataframe_vis = gdf.returndatapull(lbv.loadSQL_visitations(filepath=filepath), verbose=verbose, savefilename=savefilename_vis, overwrite=overwrite_vis)\\n\\n return dataframe_days, dataframe_vis\",\n \"def InitDataset(self):\\n train_txt = 'ImageSets/Main/train.txt'\\n val_txt = 'ImageSets/Main/val.txt'\\n annotations = \\\"Annotations\\\"\\n jpegimages = \\\"JPEGImages\\\"\\n images_path = train_txt if (self.is_train) else val_txt \\n images_path = readTxt(os.path.join(self.path, images_path))\\n images_path.pop(-1)\\n # rawdata format: [path_2_image, path_2_xml]\\n rawData = list()\\n for each in images_path:\\n xml = os.path.join(self.path, annotations, each + '.xml')\\n jpeg = os.path.join(self.path, jpegimages, each + '.jpg')\\n rawData.append([jpeg, xml])\\n return rawData\",\n \"def _compute_experiment_statistics(self):\\n pass\",\n \"def init_data(self):\\n fields = SeriesRepository.get_available_series().exclude(identifier=None)\\n\\n if self.catalog:\\n try:\\n catalog = Catalog.objects.get(identifier=self.catalog)\\n except Catalog.DoesNotExist:\\n return\\n\\n fields = fields.filter(\\n distribution__dataset__catalog=catalog\\n )\\n\\n fields = fields.prefetch_related(\\n 'distribution',\\n 'distribution__dataset',\\n 'distribution__dataset__catalog',\\n 'enhanced_meta',\\n )\\n all_meta = Metadata.objects.all()\\n field_ct = ContentType.objects.get_for_model(Field)\\n for field in fields:\\n meta = json.loads(field.metadata)\\n dist_meta = json.loads(field.distribution.metadata)\\n dataset_meta = json.loads(field.distribution.dataset.metadata)\\n themes = field.distribution.dataset.themes\\n theme_labels = get_theme_labels(json.loads(themes)) if themes else ''\\n\\n self.fields[field.identifier] = {\\n 'dataset': field.distribution.dataset,\\n 'distribution': field.distribution,\\n 'serie': field,\\n 'serie_titulo': field.title,\\n 'serie_unidades': meta.get('units'),\\n 'serie_descripcion': meta.get('description'),\\n 'distribucion_titulo': dist_meta.get('title'),\\n 'distribucion_descripcion': dist_meta.get('description'),\\n 'distribucion_url_descarga': field.distribution.download_url,\\n 'dataset_responsable': dataset_meta.get('publisher', {}).get('name'),\\n 'dataset_fuente': dataset_meta.get('source'),\\n 'dataset_titulo': field.distribution.dataset.title,\\n 'dataset_descripcion': dataset_meta.get('description'),\\n 'dataset_tema': theme_labels,\\n 'metadata': {o.key: o.value for o in list(all_meta.filter(content_type=field_ct, object_id=field.id))},\\n 'frequency': self.serie_periodicity(field),\\n }\",\n \"def make_all(self):\\n # General matrices #\\n self.tsv_seq_to_concepts()\\n self.tsv_seq_to_names()\\n self.list_sequence_concept()\\n # Only in the with 'samples' case #\\n if self.a.abundances: self.tsv_samples_to_names()\\n if self.a.abundances: self.biom_output()\\n # Graphical outputs #\\n self.per_seq_dot_files()\\n if self.a.abundances: self.per_sample_dot_files()\",\n \"def read_statistics(self):\\n self.psdata=[]\\n self.powerspectra=[]\\n self.ds=[]\\n self.dsigmasq=[]\\n self.dsigma=[]\\n self.bsdata=[]\\n self.eqbispectra=[]\\n self.fNLeq=[]\\n\\n for sub in range(self.Nsubs):\\n self.psdata.append(np.load(self.datadir+self.filebase+\\\"_\\\"+str(sub)+\\\".npy\\\"))\\n self.powerspectra.append(np.trim_zeros(self.psdata[-1][0][1:]))\\n self.bsdata.append(np.load(self.datadir+self.fbbispec+\\\"_\\\"+str(sub)+\\\".npy\\\"))\\n self.eqbispectra.append(self.bsdata[-1][0][1:len(self.powerspectra[-1])])\\n\\n self.ds.append(np.load(self.datadir+\\\"stat_\\\"+str(sub)+\\\".npy\\\")[0])\\n self.dsigmasq.append(np.load(self.datadir+\\\"stat_\\\"+str(sub)+\\\".npy\\\")[1])\\n self.dsigma = np.array([np.sqrt(dsq) for dsq in self.dsigmasq])\\n\\n self.klist=np.arange(1, len(self.powerspectra[-1]))*(2.*np.pi/self.Lsub)\\n # subtract the mean ds\\n self.ds = self.ds - np.mean(self.ds)\\n self.fNLeq=np.mean(self.eqbispectra, axis=0)\\n self.fNLeqsubs=np.mean(self.eqbispectra, axis=1)\\n self.fNLeqds=[]\\n for i in range(len(self.eqbispectra)):\\n self.fNLeqds.append(np.array([self.ds[i]*self.eqbispectra[i][j] for j in range(45)]))\",\n \"def build_dataset(self):\\n print(\\\"reading data of images currently , please wait......\\\")\\n x_train, y_train, _ = get_images(self.train_directory)\\n x_test, y_test, _ = get_images(self.test_directory)\\n x_train, y_train = image_subset(self.num_classes, x_train, y_train)\\n x_test, y_test = image_subset(self.num_classes, x_test, y_test)\\n x_train = x_train.astype('float32')\\n x_test = x_test.astype('float32')\\n self.x_train = x_train / 255\\n self.x_test = x_test / 255\\n self.y_train = utils.to_categorical(y_train, self.num_classes)\\n self.y_test = utils.to_categorical(y_test, self.num_classes)\",\n \"def _get_datas(self):\\n print(f'base name {self.base_name}')\\n data_file_name = glob(osp.join(self.root_dir, MERGED_PATTERN))[0]\\n data_df = pd.read_csv(data_file_name)\\n\\n ppg_d = data_df[['CurrentTimeMillis', 'ch1']].values\\n acc_d = data_df[[\\n 'EventTimestamp(ns)', 'accel_x', 'accel_y', 'accel_z'\\n ]].values\\n ppg_d = ppg_d[::2]\\n acc_d = acc_d[::2]\\n\\n return acc_d, ppg_d\",\n \"def getTrainingData(self):\\n raise NotImplementedError\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\\"Process the results of an experiment.\\\")\\n parser.add_argument(\\\"experiment\\\")\\n arguments = parser.parse_args()\\n path = f\\\"experiments/{arguments.experiment}\\\"\\n if not os.path.exists(path):\\n raise SystemExit(f\\\"Path {path} does not exists.\\\")\\n\\n # For efficiency, one should generate the results from the parts without merging them.\\n files = [file for file in os.listdir(path) if os.path.isfile(os.path.join(path, file))]\\n frames = []\\n for file in files:\\n device, experiment, _ = file.split(\\\".\\\")\\n frame = pandas.read_csv(\\n os.path.join(path, file),\\n index_col=\\\"variable\\\",\\n usecols=[\\\"variable\\\", \\\"group_index\\\", \\\"value_i\\\"], dtype={\\\"value_i\\\": \\\"Int64\\\"}\\n )\\n frame[\\\"board\\\"] = device\\n frame[\\\"experiment\\\"] = experiment\\n frames.append(frame)\\n dataframe = pandas.concat(frames)\\n frames = None\\n\\n current_grouping = dataframe.groupby([\\\"group_index\\\", \\\"variable\\\"])\\n \\n data = current_grouping.agg([\\n numpy.median,\\n _percentile_factory(95),\\n numpy.mean,\\n numpy.std,\\n \\\"count\\\"\\n ])\\n\\n print(data)\\n \\n data = data.droplevel([0], axis=1)\\n data = data.unstack()\\n data.columns = data.columns.map('_'.join)\\n data.to_csv(f\\\"{arguments.experiment}.csv\\\")\",\n \"def get_measurements_by_time(self):\\n data_path = os.path.abspath(\\n os.path.join(\\n os.path.dirname(os.path.realpath(__file__)),\\n \\\"..\\\",\\n \\\"data/NVB_rescale_dataset.p\\\",\\n )\\n )\\n self.log_print([\\\"Getting experimental data from {}\\\".format(data_path)])\\n self.measurements = pickle.load(open(data_path, \\\"rb\\\"))\\n return self.measurements\",\n \"def fetch_test_data(self):\\r\\n self.fetch_attribute_list()\\r\\n self.type_conversion()\\r\\n # Connect to sensor database.\\r\\n connection = db.Connection(host=\\\"localhost\\\", user=\\\"root\\\", db=\\\"sensor\\\")\\r\\n dbhandler = connection.cursor()\\r\\n test_data = []\\r\\n for i in range(0, len(self.attribute_list)):\\r\\n # If the value is in user_info.json file.\\r\\n if self.attribute_list[i] in self.form_attribute_keys == True:\\r\\n test_data.append(self.form_attribute[self.attribute_list[i]])\\r\\n else:\\r\\n # Value is in database.\\r\\n # Reconstruct attribute name to match with table column name.\\r\\n self.attribute_list[i] = self.attribute_list[i].replace(' ', '_')\\r\\n self.attribute_list[i] = self.attribute_list[i].lower()\\r\\n # Fetch last inserted value of that attribute.\\r\\n query = \\\"select `\\\"\\r\\n query += (self.attribute_list[i] + \\\"`FROM `\\\" + self.attribute_list[i]\\r\\n + \\\"` ORDER BY `\\\" + self.attribute_list[i] + \\\"` DESC LIMIT 1\\\")\\r\\n dbhandler.execute(query=query)\\r\\n value = dbhandler.fetchall()\\r\\n print value\\r\\n # Append to test_data\\r\\n test_data.append(value[0][0])\\r\\n print test_data\\r\\n return np.array(test_data)\",\n \"def extract(self):\\n\\n # print some infos about data\\n print(\\\"\\\\n--extract batches from data:\\\\ntrain: {}\\\\nval: {}\\\\ntest: {}\\\\n\\\".format(self.data[0]['x'].shape, self.data[1]['x'].shape, self.data[2]['x'].shape))\\n\\n # create batches\\n self.x_train, self.y_train, _ = self.create_batches(self.data[0], batch_size=self.batch_size)\\n self.x_val, self.y_val, _ = self.create_batches(self.data[1], batch_size=self.batch_size_eval)\\n self.x_test, self.y_test, _ = self.create_batches(self.data[2], batch_size=self.batch_size_eval)\\n\\n # my data\\n if len(self.mfcc_data_files) == 4:\\n self.x_my, self.y_my, self.z_my = self.create_batches(self.data[3], batch_size=1)\",\n \"def template_dataset(self):\\n exp_dict = {\\n 'experiment_name': 'ALLEN_all_neurons',\\n 'only_process_n': None, # Set to None to process all\\n 'randomize_selection': True,\\n 'reference_image_key': {'proc_stimuli': 'image'},\\n 'reference_label_key': {'neural_trace_trimmed': 'label'},\\n 'rf_query': [{\\n 'rf_coordinate_range': { # Get all cells\\n 'x_min': 40,\\n 'x_max': 70,\\n 'y_min': 20,\\n 'y_max': 50,\\n },\\n 'cre_line': 'Cux2',\\n 'structure': 'VISp'}\\n ],\\n 'cross_ref': 'rf_coordinate_range_and_stimuli',\\n 'store_means': [\\n 'image',\\n 'label'\\n ],\\n 'cc_repo_vars': {\\n 'output_size': [2, 1], # target variable -- neural activity,\\n 'model_im_size': [152, 304, 1],\\n 'loss_function': 'pearson',\\n 'score_metric': 'pearson',\\n 'preprocess': 'resize'\\n },\\n # 'deconv_method': 'elephant'\\n }\\n exp_dict = self.add_globals(exp_dict)\\n return exp_dict\",\n \"def get_data(dataset, **kwargs):\\n age_df = load_age_sample_from_mcmc_chains(dataset, **kwargs)\\n hr_df = load_hr()\\n age_df, hr_df = clean_data(age_df, hr_df)\\n snids = age_df.index.unique().tolist()\\n return snids, age_df, hr_df\",\n \"def get_uniform_dist_data(debug, dataset, resamplefactor, raw, analysis):\\n\\n project_wd, project_data, project_sink = get_paths(debug, dataset)\\n\\n demographics, imgs, dataframe = get_data(project_data, dataset,\\n debug, project_wd,\\n resamplefactor,\\n raw=raw,\\n analysis=analysis)\\n\\n # transform age into ints\\n demographics['age_int'] = demographics['age'].astype('int32', copy=False)\\n\\n # Select 14 subjects for all ages that have 14 representatives.\\n age_range = np.arange(demographics['age'].min(), demographics['age'].max())\\n # remove entry where you don't have 14 subjects\\n max_n = 14\\n age_to_remove = [35, 36, 39, 42, 78, 79, 80, 81, 82, 83, 85, 89]\\n age_range = np.setdiff1d(age_range, age_to_remove)\\n # iterate over the dataframe and select 14 subjects for each age range\\n ids_to_use = []\\n for age in age_range:\\n ids_to_use.append(demographics.index[demographics['age_int'] ==\\n age].tolist()[:max_n])\\n\\n # flatten ids_to_use\\n ids_to_use = [item for sublist in ids_to_use for item in sublist]\\n # Filter the demographics dataframe\\n demographics = demographics[demographics.index.isin(ids_to_use)]\\n # set subject's id as index\\n # filter dataset using index of the subjects\\n dataframe = dataframe.loc[demographics['id']]\\n\\n # Print some diagnosis\\n print('Shape of the new demographics:')\\n print(demographics.shape)\\n print('Oldest %d and youngest %d subject' %(demographics['age_int'].max(),\\n demographics['age_int'].min()))\\n print('Number of age bins %d' %len(demographics['age_int'].unique()))\\n return demographics, dataframe\",\n \"def lego_sets():\\n \\n \\n data_test=data_specific\\n\\n\\n\\n \\n \\n\\n \\n print(data_test)\\n print(\\\"The size of the data is: \\\",len(data_test))\\n \\n \\n \\n # you must replace this line and return your own list\\n return data_test\",\n \"def get_datadfs(self, recal=True):\\n\\n # those files contain score >1\\n trn_fname = os.path.join(self.save_dir, 'reg_trn_set_df.csv')\\n val_fname = os.path.join(self.save_dir, 'reg_val_set_df.csv')\\n tst_fname = os.path.join(self.save_dir, 'reg_tst_set_df.csv')\\n\\n if os.path.exists(trn_fname) and os.path.exists(val_fname) and os.path.exists(tst_fname) and not recal:\\n logging.info('reading...\\\\n{}\\\\n{}\\\\n{}'.format(trn_fname, val_fname, tst_fname))\\n trn_set_df = pd.read_csv(trn_fname, sep='\\\\t')\\n val_set_df = pd.read_csv(val_fname, sep='\\\\t')\\n tst_set_df = pd.read_csv(tst_fname, sep='\\\\t')\\n else:\\n # read phage and bact relation file\\n data_meta_info_f = self.config['data_meta_info']\\n if not os.path.exists(data_meta_info_f):\\n logging.error('data meta information file not Found. {}'.format(data_meta_info_f))\\n raise FileNotFoundError('data meta information file not Found')\\n data_info = pd.read_csv(data_meta_info_f)\\n logging.info('total samples: {}'.format(len(data_info)))\\n\\n # select specific columns\\n sel_cols = 'hostID,phageID,b_Score,phage_bac_name,bac_len,phage_len'.split(',')\\n data_info_df = data_info[sel_cols]\\n\\n # select rows with score > 1\\n data_info_sel = data_info_df[data_info_df['b_Score'] > 1].copy()\\n data_info_sel.reset_index(drop=True, inplace=True)\\n\\n b_scores = data_info_sel['b_Score'].values\\n b_scores = b_scores.reshape(-1, 1)\\n\\n # MinMaxScaler()\\n mm_scaler = MinMaxScaler()\\n mm_scaler.fit(b_scores)\\n mm_scaler_fname = os.path.join(self.save_dir, 'minmax_scaler.joblib')\\n if os.path.exists(mm_scaler_fname):\\n os.remove(mm_scaler_fname)\\n dump(mm_scaler, mm_scaler_fname)\\n data_info_sel['minmax_bscore'] = np.squeeze(mm_scaler.transform(b_scores))\\n\\n # StandardScaler()\\n ss_scaler = StandardScaler()\\n ss_scaler.fit(b_scores)\\n ss_scaler_fname = os.path.join(self.save_dir, 'standard_scaler.joblib')\\n if os.path.exists(ss_scaler_fname):\\n os.remove(ss_scaler_fname)\\n dump(ss_scaler, ss_scaler_fname)\\n data_info_sel['norm_bscore'] = np.squeeze(ss_scaler.transform(b_scores))\\n\\n # MaxAbsScaler()\\n ma_scaler = MaxAbsScaler()\\n ma_scaler.fit(b_scores)\\n ma_scaler_fname = os.path.join(self.save_dir, 'maxabs_scaler.joblib')\\n if os.path.exists(ma_scaler_fname):\\n os.remove(ma_scaler_fname)\\n dump(ma_scaler, ma_scaler_fname)\\n data_info_sel['maxabs_bscore'] = np.squeeze(ma_scaler.transform(b_scores))\\n\\n logging.info('number of samples with score > 1 : {}'.format(len(data_info_sel)))\\n\\n # creat train, validation and test dataset\\n # split dataframe, 80% for train , 10% for validation and 10% for test\\n trn_set_df, val_set_df, tst_set_df = np.split(data_info_sel.sample(frac=1, random_state=1),\\n [int(.7*len(data_info_sel)), int(.85*len(data_info_sel))])\\n\\n trn_set_df.reset_index(drop=True, inplace=True)\\n val_set_df.reset_index(drop=True, inplace=True)\\n tst_set_df.reset_index(drop=True, inplace=True)\\n\\n if os.path.exists(trn_fname):\\n os.remove(trn_fname)\\n trn_set_df.to_csv(trn_fname, sep='\\\\t', index=False)\\n if os.path.exists(val_fname):\\n os.remove(val_fname)\\n val_set_df.to_csv(val_fname, sep='\\\\t', index=False)\\n if os.path.exists(tst_fname):\\n os.remove(tst_fname)\\n tst_set_df.to_csv(tst_fname, sep='\\\\t', index=False)\\n\\n logging.info('train sample: {}'.format(len(trn_set_df)))\\n logging.info('valid sample: {}'.format(len(val_set_df)))\\n logging.info('test sample: {}'.format(len(tst_set_df)))\\n\\n return trn_set_df, val_set_df, tst_set_df\",\n \"def datasets(self):\\n return [Dataset.ENSEMBL]\",\n \"def _make_meta(self):\\n available_meas_times = list()\\n available_intervals = list()\\n drill_by = list()\\n related = list()\\n last_data_set_instance = dict()\\n\\n if self._data['report_save_historical_instances_ind'] == 'Y':\\n # last measurement instance\\n res = self._db.Query(\\\"\\\"\\\"SELECT *\\n FROM report_data_set_instance\\n WHERE\\n `element_id`=%s\\n AND `segment_value_id` = %s\\n ORDER BY measurement_time DESC\\n LIMIT 0, 1\\\"\\\"\\\",(self._id, self._segment_value_id))\\n if res:\\n last_data_set_instance = self._db.record[0]\\n last_data_set_instance['measurement_time'] = self._formatter.format_date(last_data_set_instance['measurement_time'])\\n\\n # available measurement instances\\n res = self._db.Query(\\\"\\\"\\\"SELECT *\\n FROM report_data_set_instance\\n WHERE\\n `element_id`=%s\\n AND `segment_value_id` = %s\\n ORDER BY measurement_time DESC\\\"\\\"\\\",(self._id, self._segment_value_id))\\n if res:\\n for data_set_instance in self._db.record:\\n data_set_instance['measurement_time'] = self._formatter.format_date(data_set_instance['measurement_time'])\\n available_meas_times.append(data_set_instance)\\n \\n\\n # get drill by. not for this version\\n\\n # available measurement intervals\\n if self._data['report_primary_shared_dimension_id'] is None:\\n self._data['report_primary_shared_dimension_id'] = 0\\n\\n self._db.Query(\\\"\\\"\\\"\\n SELECT measurement_interval.*,\\n dashboard_element.element_id\\n FROM dashboard_element\\n LEFT JOIN measurement_interval\\n ON measurement_interval.measurement_interval_id = dashboard_element.measurement_interval_id\\n WHERE\\n (dashboard_element.`element_id`<>%s\\n AND dashboard_element.measurement_interval_id <> %s\\n AND dashboard_element.shared_measure_id = %s\\n AND dashboard_element.`type` = 'internal report'\\n AND ifnull(dashboard_element.report_used_for_drill_to_ind,'N') = %s\\n AND ifnull(dashboard_element.report_primary_shared_dimension_id,0) = %s\\n AND ifnull(dashboard_element.segment_id,0) = %s)\\n OR\\n dashboard_element.`element_id`=%s\\n AND 3=4\\n \\n GROUP BY measurement_interval.measurement_interval_id\\n ORDER BY\\n measurement_interval.display_sequence,\\n dashboard_element.name ASC\\n \\\"\\\"\\\",\\n (self._id,\\n self._data['measurement_interval_id'],\\n self._data['shared_measure_id'],\\n self._data['report_used_for_drill_to_ind'],\\n self._data['report_primary_shared_dimension_id'],\\n self._data['segment_id'],\\n self._id))\\n\\n\\n for interval in self._db.record:\\n interval['report_data_set_instance_id'] = 0\\n available_intervals.append(interval)\\n\\n # see related\\n self._db.Query(\\\"\\\"\\\"SELECT e.*\\n FROM dashboard_element_topic det, dashboard_element e\\n WHERE e.element_id = det.dashboard_element_id\\n AND dashboard_element_id <> %s\\n AND e.enabled_ind = 'Y'\\n AND topic_id IN (select topic_id from dashboard_element_topic where dashboard_element_id = %s)\\n UNION SELECT e.*\\n FROM dashboard_element e, metric_drill_to_report m\\n WHERE m.metric_element_id = e.element_id\\n AND m.report_element_id = %s\\n AND e.enabled_ind = 'Y'\\n AND ifnull(e.segment_id,0) = %s\\n \\\"\\\"\\\", (self._id, self._id, self._id, self._data['segment_id']))\\n \\n\\n for related_element in self._db.record:\\n if not related_element['segment_id']:\\n related_element['segment_id'] = 0\\n if related_element['segment_id'] == self._data['segment_id']:\\n related_element['segment_value_id'] = self._segment_value_id\\n else:\\n related_element['segment_value_id'] = 0\\n related.append(related_element)\\n\\n # elements displayed on the page\\n before_dataset = list()\\n after_dataset = list()\\n \\n charts_before_dataset = list()\\n charts_after_dataset = list()\\n \\n \\n # dataset table\\n dataset_el = OrderedDict()\\n dataset_el['element_id'] = ''\\n dataset_el['element_type'] = 'dataset'\\n dataset_el['element_name'] = ''\\n dataset_el['element_desc'] = ''\\n dataset_el['placement'] = ''\\n dataset_el['sequence'] = 0\\n dataset_el['show_ind'] = self._data['show_data_set_table_in_report_ind']\\n \\n \\n # charts\\n self._db.Query(\\\"\\\"\\\"SELECT *\\n FROM report_data_set_chart \\n WHERE \\n `element_id`= %s\\n AND \\n (ISNULL(report_data_set_pivot_id)\\n OR report_data_set_pivot_id = 0) \\n ORDER BY display_sequence ASC\\\"\\\"\\\", (self._id, ))\\n for chart in self._db.record:\\n chart_el = OrderedDict()\\n chart_el['element_id'] = chart['report_data_set_chart_id']\\n chart_el['element_type'] = 'chart'\\n chart_el['pivot_id'] = 0\\n if chart['report_data_set_pivot_id']:\\n chart_el['pivot_id'] = chart['report_data_set_pivot_id']\\n chart_el['element_name'] = chart['name']\\n chart_el['element_desc'] = chart['description']\\n chart_el['placement'] = chart['chart_placement']\\n chart_el['sequence'] = chart['display_sequence']\\n chart_el['show_ind'] = chart['enabled_ind']\\n if chart_el['placement'] == 'before table': \\n charts_before_dataset.append(chart_el)\\n else:\\n charts_after_dataset.append(chart_el)\\n \\n # pivots\\n self._db.Query(\\\"\\\"\\\"SELECT *\\n FROM report_data_set_pivot\\n WHERE\\n `element_id`= %s\\n ORDER BY display_sequence ASC\\\"\\\"\\\", (self._id, ))\\n for pivot in self._db.record:\\n before_pivot = list()\\n after_pivot = list()\\n #pivot_element = list()\\n \\n pivot_el = OrderedDict()\\n pivot_el['element_id'] = pivot['report_data_set_pivot_id']\\n pivot_el['element_type'] = 'pivot'\\n pivot_el['element_name'] = pivot['name']\\n pivot_el['element_desc'] = ''\\n pivot_el['placement'] = pivot['pivot_table_report_placement']\\n pivot_el['sequence'] = pivot['display_sequence']\\n pivot_el['show_ind'] = pivot['enabled_ind']\\n \\n # charts\\n self._db.Query(\\\"\\\"\\\"SELECT *\\n FROM report_data_set_chart \\n WHERE \\n `element_id`= %s\\n AND report_data_set_pivot_id = %s \\n ORDER BY display_sequence ASC\\\"\\\"\\\",\\n (self._id, pivot_el['element_id']))\\n for chart in self._db.record:\\n chart_el = OrderedDict()\\n chart_el['element_id'] = chart['report_data_set_chart_id']\\n chart_el['element_type'] = 'chart'\\n chart_el['pivot_id'] = 0\\n if chart['report_data_set_pivot_id']:\\n chart_el['pivot_id'] = chart['report_data_set_pivot_id']\\n chart_el['element_name'] = chart['name']\\n chart_el['element_desc'] = chart['description']\\n chart_el['placement'] = chart['chart_placement']\\n chart_el['sequence'] = chart['display_sequence']\\n chart_el['show_ind'] = chart['enabled_ind']\\n if chart_el['placement'] == 'before table': \\n before_pivot.append(chart_el)\\n else:\\n after_pivot.append(chart_el)\\n pivot_element = before_pivot + [pivot_el] + after_pivot \\n \\n if pivot_el['placement'] == 'before data set':\\n before_dataset += pivot_element\\n else:\\n after_dataset += pivot_element\\n elements = charts_before_dataset + before_dataset + [dataset_el] + after_dataset + charts_after_dataset\\n \\n \\n self._jfile.make_current_meta(last_data_set_instance,\\n available_meas_times,\\n available_intervals,\\n drill_by,\\n related,\\n elements,\\n self._segment_values)\",\n \"def _get_raw_data(self, idx=0):\\n # Get the time step then make a data frame\\n raise NotImplementedError('Code me up!')\\n #data = self._data[???]\\n return data\",\n \"def get_stats():\\n datasets = [\\n (\\\"../data_processing/data/page2answer_single_abstractive_summ.json\\\", \\\"p2a-single-abs\\\"),\\n (\\\"../data_processing/data/page2answer_single_extractive_summ.json\\\", \\\"p2a-single-ext\\\"),\\n (\\\"../data_processing/data/section2answer_multi_abstractive_summ.json\\\", \\\"s2a-multi-abs\\\"),\\n (\\\"../data_processing/data/page2answer_multi_extractive_summ.json\\\", \\\"p2a-multi-ext\\\"),\\n (\\\"../data_processing/data/section2answer_single_abstractive_summ.json\\\", \\\"s2a-single-abs\\\"),\\n (\\\"../data_processing/data/section2answer_single_extractive_summ.json\\\", \\\"s2a-single-ext\\\"),\\n (\\\"../data_processing/data/section2answer_multi_extractive_summ.json\\\", \\\"s2a-multi-ext\\\"),\\n (\\\"../data_processing/data/question_driven_answer_summarization_primary_dataset.json\\\", \\\"complete_dataset\\\"),\\n ]\\n\\n stats = SummarizationDataStats()\\n for dataset in datasets:\\n print(dataset[1])\\n stats.load_data(dataset[0], dataset[1])\\n stats.iterate_data()\",\n \"def _data(self) -> List[Data]:\\n data = []\\n sample_ids, repeated_sample_ids = set(), set()\\n for datum in self.collection.data.filter(\\n type=self.process_type,\\n status=\\\"OK\\\",\\n ordering=\\\"-created\\\",\\n fields=self.DATA_FIELDS,\\n ):\\n # 1 Filter by newest datum in the sample\\n if datum.sample.id in sample_ids:\\n repeated_sample_ids.add(datum.sample.id)\\n continue\\n\\n # 2 Filter by genes, if geneset is given\\n if self.geneset:\\n obj_geneset = self._get_obj_geneset(datum)\\n if not self.geneset.issubset(obj_geneset):\\n warnings.warn(\\n f\\\"Sample {datum.sample} (Data {datum.id}) does not \\\"\\n \\\"contain the genes requested in geneset input.\\\"\\n )\\n continue\\n\\n sample_ids.add(datum.sample.id)\\n data.append(datum)\\n\\n if repeated_sample_ids:\\n repeated = \\\", \\\".join(map(str, repeated_sample_ids))\\n warnings.warn(\\n f\\\"The following samples have multiple data of type {self.process_type}: \\\"\\n f\\\"{repeated}. Using only the newest data of this sample.\\\",\\n UserWarning,\\n )\\n\\n if not data:\\n raise ValueError(\\n f\\\"Collection {self.collection.name} has no {self.process_type} \\\"\\n \\\"data or there is no data with the requested mutations.\\\"\\n )\\n\\n return data\",\n \"def decode(self):\\n # Extract all the experiments\\n\\n # Map of imageset/scan pairs\\n imagesets = {}\\n\\n # For every experiment, use the given input to create\\n # a sensible experiment.\\n el = ExperimentList()\\n for eobj in self._obj[\\\"experiment\\\"]:\\n\\n # Get the models\\n identifier = eobj.get(\\\"identifier\\\", \\\"\\\")\\n beam = self._lookup_model(\\\"beam\\\", eobj)\\n detector = self._lookup_model(\\\"detector\\\", eobj)\\n goniometer = self._lookup_model(\\\"goniometer\\\", eobj)\\n scan = self._lookup_model(\\\"scan\\\", eobj)\\n crystal = self._lookup_model(\\\"crystal\\\", eobj)\\n profile = self._lookup_model(\\\"profile\\\", eobj)\\n scaling_model = self._lookup_model(\\\"scaling_model\\\", eobj)\\n\\n key = (eobj.get(\\\"imageset\\\"), eobj.get(\\\"scan\\\"))\\n\\n imageset = None\\n try:\\n imageset = imagesets[key] # type: ImageSet\\n except KeyError:\\n # This imageset hasn't been loaded yet - create it\\n imageset_data = self._lookup_model(\\\"imageset\\\", eobj)\\n\\n # Create the imageset from the input data\\n if imageset_data is not None:\\n if \\\"params\\\" in imageset_data:\\n format_kwargs = imageset_data[\\\"params\\\"]\\n else:\\n format_kwargs = {}\\n\\n # Load the external lookup data\\n mask_filename, mask = self._load_pickle_path(imageset_data, \\\"mask\\\")\\n gain_filename, gain = self._load_pickle_path(imageset_data, \\\"gain\\\")\\n pedestal_filename, pedestal = self._load_pickle_path(\\n imageset_data, \\\"pedestal\\\"\\n )\\n dx_filename, dx = self._load_pickle_path(imageset_data, \\\"dx\\\")\\n dy_filename, dy = self._load_pickle_path(imageset_data, \\\"dy\\\")\\n\\n if imageset_data[\\\"__id__\\\"] == \\\"ImageSet\\\":\\n imageset = self._make_stills(\\n imageset_data, format_kwargs=format_kwargs\\n )\\n elif imageset_data[\\\"__id__\\\"] == \\\"ImageGrid\\\":\\n imageset = self._make_grid(\\n imageset_data, format_kwargs=format_kwargs\\n )\\n elif (\\n imageset_data[\\\"__id__\\\"] == \\\"ImageSequence\\\"\\n or imageset_data[\\\"__id__\\\"] == \\\"ImageSweep\\\"\\n ):\\n imageset = self._make_sequence(\\n imageset_data,\\n beam=beam,\\n detector=detector,\\n goniometer=goniometer,\\n scan=scan,\\n format_kwargs=format_kwargs,\\n )\\n elif imageset_data[\\\"__id__\\\"] == \\\"MemImageSet\\\":\\n imageset = self._make_mem_imageset(imageset_data)\\n else:\\n raise RuntimeError(\\\"Unknown imageset type\\\")\\n\\n if imageset is not None:\\n # Set the external lookup\\n if mask is None:\\n mask = ImageBool()\\n else:\\n mask = ImageBool(mask)\\n if gain is None:\\n gain = ImageDouble()\\n else:\\n gain = ImageDouble(gain)\\n if pedestal is None:\\n pedestal = ImageDouble()\\n else:\\n pedestal = ImageDouble(pedestal)\\n if dx is None:\\n dx = ImageDouble()\\n else:\\n dx = ImageDouble(dx)\\n if dy is None:\\n dy = ImageDouble()\\n else:\\n dy = ImageDouble(dy)\\n\\n if not imageset.external_lookup.mask.data.empty():\\n if not mask.empty():\\n mask = tuple(m.data() for m in mask)\\n for m1, m2 in zip(\\n mask, imageset.external_lookup.mask.data\\n ):\\n m1 &= m2.data()\\n imageset.external_lookup.mask.data = ImageBool(mask)\\n else:\\n imageset.external_lookup.mask.data = mask\\n imageset.external_lookup.mask.filename = mask_filename\\n imageset.external_lookup.gain.data = gain\\n imageset.external_lookup.gain.filename = gain_filename\\n imageset.external_lookup.pedestal.data = pedestal\\n imageset.external_lookup.pedestal.filename = pedestal_filename\\n imageset.external_lookup.dx.data = dx\\n imageset.external_lookup.dx.filename = dx_filename\\n imageset.external_lookup.dy.data = dy\\n imageset.external_lookup.dy.filename = dy_filename\\n\\n # Update the imageset models\\n if isinstance(imageset, ImageSequence):\\n imageset.set_beam(beam)\\n imageset.set_detector(detector)\\n imageset.set_goniometer(goniometer)\\n imageset.set_scan(scan)\\n elif isinstance(imageset, (ImageSet, ImageGrid)):\\n for i in range(len(imageset)):\\n imageset.set_beam(beam, i)\\n imageset.set_detector(detector, i)\\n imageset.set_goniometer(goniometer, i)\\n imageset.set_scan(scan, i)\\n\\n imageset.update_detector_px_mm_data()\\n\\n # Add the imageset to the dict - even if empty - as this will\\n # prevent a duplicated attempt at reconstruction\\n imagesets[key] = imageset\\n\\n # Append the experiment\\n el.append(\\n Experiment(\\n imageset=imageset,\\n beam=beam,\\n detector=detector,\\n goniometer=goniometer,\\n scan=scan,\\n crystal=crystal,\\n profile=profile,\\n scaling_model=scaling_model,\\n identifier=identifier,\\n )\\n )\\n\\n # Return the experiment list\\n return el\",\n \"def get_content(self):\\r\\n return self.parameters, self.spectrum\",\n \"def collect_data(self):\\n exp_conf: ec.ExperimentConfiguration\\n # Disabled multiprocess run because of huge memory usage\\n processes_number = 1 # self._campaign_configuration['General']['j']\\n if processes_number == 1:\\n self._logger.info(\\\"-->Evaluate experiments (sequentially)\\\")\\n for exp_conf in tqdm.tqdm(self._exp_confs, dynamic_ncols=True):\\n exp_conf.evaluate()\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n exp_conf.generate_plots()\\n self._logger.info(\\\"<--\\\")\\n else:\\n self._logger.info(\\\"-->Evaluate experiments (in parallel)\\\")\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(evaluate_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n if bool(self._campaign_configuration['General']['generate_plots']):\\n pool = multiprocessing.Pool(processes_number)\\n self._exp_confs = list(tqdm.tqdm(pool.imap(plot_wrapper, self._exp_confs), total=len(self._exp_confs)))\\n self._logger.info(\\\"<--\\\")\\n\\n self.raw_results = {}\\n for exp_conf in self._exp_confs:\\n self.raw_results[tuple(exp_conf.get_signature())] = exp_conf.mapes\",\n \"def process_raw_data(self):\\n \\n # Define some variables of interest.\\n vor = [\\\"n_sentences\\\", \\\"n_correct\\\", \\\"p_correct\\\", \\\"median_RT\\\", \\\\\\n \\\"mean_RT\\\", \\\"stdev_RT\\\", \\\"scaled_stdev_RT\\\"]\\n \\n # Get all participant names, or return straight away if no data was\\n # loaded yet.\\n if hasattr(self, \\\"raw\\\"):\\n participants = self.raw.keys()\\n participants.sort()\\n else:\\n self.data = None\\n return\\n\\n # Count the number of participants.\\n n = len(participants)\\n \\n # Create a data dict for each variable of interest.\\n self.data = {}\\n self.data[\\\"ppname\\\"] = []\\n for var in vor:\\n self.data[var] = numpy.zeros(n, dtype=float) * numpy.NaN\\n \\n # Loop through all participants.\\n for i, ppname in enumerate(participants):\\n # Add the participant name.\\n self.data[\\\"ppname\\\"].append(copy.deepcopy(ppname))\\n # Skip empty datasets.\\n if self.raw[ppname] is None:\\n continue\\n # Compute stuff relevant to this task.\\n self.data[\\\"n_sentences\\\"][i] = len(self.raw[ppname][\\\"Sentence\\\"])\\n self.data[\\\"n_correct\\\"][i] = numpy.sum(self.raw[ppname][\\\"correct\\\"])\\n self.data[\\\"p_correct\\\"][i] = float(self.data[\\\"n_correct\\\"][i]) \\\\\\n / float(self.data[\\\"n_sentences\\\"][i])\\n self.data[\\\"median_RT\\\"][i] = numpy.nanmedian(self.raw[ppname][\\\"RT\\\"])\\n self.data[\\\"mean_RT\\\"][i] = numpy.nanmean(self.raw[ppname][\\\"RT\\\"])\\n self.data[\\\"stdev_RT\\\"][i] = numpy.nanstd(self.raw[ppname][\\\"RT\\\"])\\n # Compute a scaled standard deviation of the response time, scaled to the\\n # median response time to remove the correlation between the two.\\n self.data[\\\"scaled_stdev_RT\\\"] = self.data[\\\"stdev_RT\\\"] / self.data[\\\"median_RT\\\"]\",\n \"def __getitem__(self, type: str):\\n nodes = pandas.read_csv(join(self.base_path, \\\"nodes.csv\\\"))\\n edges = pandas.read_csv(join(self.base_path, \\\"held.csv\\\"))\\n if type == \\\"link\\\":\\n # nodes = pandas.read_csv(join(self.base_path, \\\"nodes.csv\\\"))\\n held = pandas.read_csv(join(self.base_path, \\\"held.csv\\\"))\\n\\n held = held.query('type == 8')[['src', 'dst']]\\n\\n # node_pool = set(self.splits[2])\\n # held = keep_from_set(held, node_pool)\\n\\n return Experiment(self.embed, nodes, edges, held, split_on=\\\"nodes\\\", neg_sampling_strategy=\\\"word2vec\\\", compact_dst=False)\\n\\n elif type == \\\"apicall\\\":\\n api_seq = pandas.read_csv(self.experiments['apicall'])\\n\\n # unique_nodes = set(nodes['id'].values.tolist())\\n\\n # api_seq_test = api_seq.copy()\\n # api_seq_test['src'] = api_seq_test['src'].apply(lambda nid: nid if nid in unique_nodes else None)\\n # api_seq_test['dst'] = api_seq_test['dst'].apply(lambda nid: nid if nid in unique_nodes else None)\\n # api_seq_test.dropna(axis=0, inplace=True)\\n\\n # disabled for testing\\n # api_seq = api_seq[\\n # api_seq['src'].apply(lambda nid: nid in unique_nodes)\\n # ]\\n #\\n # api_seq = api_seq[\\n # api_seq['dst'].apply(lambda nid: nid in unique_nodes)\\n # ]\\n\\n node_pool = set(self.splits[2])\\n api_seq = keep_from_set(api_seq, node_pool)\\n\\n return Experiment(self.embed, nodes, edges, api_seq, split_on=\\\"nodes\\\", neg_sampling_strategy=\\\"word2vec\\\", compact_dst=False)\\n\\n elif type == \\\"typeuse\\\":\\n held = pandas.read_csv(join(self.base_path, \\\"held.csv\\\"))\\n\\n held = held.query('type == 2')[['src', 'dst']]\\n\\n # node_pool = set(self.splits[2])\\n # held = keep_from_set(held, node_pool)\\n\\n return Experiment(self.embed, nodes, edges, held, split_on=\\\"nodes\\\", neg_sampling_strategy=\\\"word2vec\\\", compact_dst=False)\\n\\n elif type == \\\"varuse\\\":\\n var_use = pandas.read_csv(self.experiments['varuse'])\\n\\n # unique_nodes = set(nodes['id'].values.tolist())\\n node_pool = set(self.splits[2])\\n\\n var_use = var_use[\\n var_use['src'].apply(lambda nid: nid in node_pool)\\n ]\\n\\n return Experiment2(self.embed, nodes, edges, var_use, split_on=\\\"nodes\\\", neg_sampling_strategy=\\\"word2vec\\\")\\n\\n elif type == \\\"fname\\\":\\n\\n # fname = pandas.read_csv(self.experiments['fname'])\\n functions = nodes.query('label == 4096')\\n functions['fname'] = functions['name'].apply(lambda name: name.split(\\\".\\\")[-1])\\n\\n functions['src'] = functions['id']\\n functions['dst'] = functions['fname']\\n\\n # unique_nodes = set(nodes['id'].values.tolist())\\n node_pool = set(self.splits[2])\\n\\n functions = functions[\\n functions['src'].apply(lambda nid: nid in node_pool)\\n ]\\n\\n # use edge splits when outgoing degree is 1\\n\\n return Experiment2(self.embed, nodes, edges, functions[['src', 'dst']], split_on=\\\"edges\\\", neg_sampling_strategy=\\\"word2vec\\\")\\n\\n elif type == \\\"nodetype\\\":\\n\\n types = nodes.copy()\\n types['src'] = nodes['id']\\n types['dst'] = nodes['label']\\n\\n print(\\\"WARNING: Make sure that you target label is stored in the field: label\\\")\\n # raise Warning(\\\"Make sure that you target label is stored in the field: label\\\")\\n\\n node_pool = set(self.splits[2])\\n\\n types['src'] = types['src'].apply(lambda nid: nid if nid in node_pool else None)\\n types = types.dropna(axis=0)\\n\\n return Experiment3(self.embed, nodes, edges, types[['src', 'dst']], split_on=\\\"edges\\\", neg_sampling_strategy=\\\"word2vec\\\")\\n else:\\n raise ValueError(f\\\"Unknown experiment: {type}. The following experiments are available: [apicall|link|typeuse|varuse|fname|nodetype].\\\")\",\n \"def _load_data(self):\\n\\n path_data_x = '/workspace/base-ml/data/dizzyreg/t%s_df.csv' % \\\\\\n self.task_num\\n path_data_y = '/workspace/base-ml/data/dizzyreg/label_df_t%s.csv' % self.task_num\\n path_meta = '/workspace/base-ml/data/dizzyreg/meta_df_t%s.csv' % self.task_num\\n path_numerical_columns = '/workspace/base-ml/data/dizzyreg/num_columns_v2.csv'\\n path_nonnumerical_columns = '/workspace/base-ml/data/dizzyreg/non_num_columns_v2.csv'\\n\\n read_data_x = pd.read_csv(path_data_x)\\n read_data_y = pd.read_csv(path_data_y)\\n read_data_meta = pd.read_csv(path_meta)\\n\\n # Drop columns if it only contains 1 unique element\\n read_data_x = pd.DataFrame(self.drop_one_elem_columns(read_data_x))\\n\\n num_col = pd.read_csv(path_numerical_columns)\\n num_col = read_data_x.columns.isin(num_col['0'].values).nonzero()[0]\\n col_idx = np.arange(read_data_x.shape[-1])\\n non_num_col = np.setdiff1d(col_idx, num_col)\\n\\n # new_data_x = np.array(read_data_x).astype(np.float32)\\n new_data_x = np.array(read_data_x)\\n new_data_y = np.array(read_data_y).astype(np.float32)\\n new_data_meta = np.array(read_data_meta).astype(np.float32)\\n\\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\\n\\n\\n # Winsorize dataset\\n len_feat = new_data_x.shape[-1]\\n idx_list = list(num_col)\\n for i in range(len_feat):\\n if i in idx_list:\\n cur_data = new_data_x[:, i]\\n cur_data = np.array(cur_data)\\n lower_p = np.percentile(cur_data, 5)\\n higher_p = np.percentile(cur_data, 95)\\n cur_data[cur_data < lower_p] = lower_p\\n cur_data[cur_data > higher_p] = higher_p\\n new_data_x[:, i] = cur_data\\n\\n # Make sure target data is one-hot encoded\\n if new_data_y.shape[-1] == 1:\\n num_class = len(np.unique(new_data_y))\\n new_data_y = np.eye(num_class)[new_data_y.astype(int).reshape(-1)]\\n new_data_y = new_data_y.astype('float32')\\n self.orig_column_names = read_data_x.columns\\n self.data_x = new_data_x # N x F\\n self.data_y = new_data_y # N x C\\n self.numerical_idx = num_col # list of idx\\n self.non_num_idx = non_num_col # None\\n\\n # Calculate adjacency matrix\\n self.meta_inf = new_data_meta.astype('float32') # N x 3\\n if self.args.graph_type:\\n self.adj = self.get_adjacency()\",\n \"def _generate_experimental_data(self):\\n\\n loginfo('Extracting dataset...')\\n cfg = self.cfg_\\n return ex.ExperimentalData(db=cfg.db,\\n prediction_label=cfg.prediction_label,\\n games=cfg.games,\\n folds=cfg.training_rounds,\\n fold_size=cfg.training_samples_per_round,\\n grid_search_folds=cfg.grid_search_folds,\\n grid_search_fold_size=\\n cfg.grid_search_samples_per_fold,\\n sampling=cfg.data_sampling,\\n lognormal=cfg.lognormal,\\n power_transform=cfg.power_transform,\\n bin_ranges=cfg.bin_ranges,\\n batch_size=self.batch_size_)\",\n \"def GetData(self):\\r\\n if self.Error == False:\\r\\n Extra = {}\\r\\n try:\\r\\n result = {}\\r\\n temp = self.ScrapeMainWebpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n temp = self.ScrapeParameters1Webpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n temp = self.ScrapeParameters2Webpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n temp = self.ScrapeStatusWebpage()\\r\\n if temp != None:\\r\\n result.update(temp)\\r\\n sqlArray = {}\\r\\n sqlArray[self.deviceDescr] = {}\\r\\n sqlArray[self.deviceDescr][self.devNumber] = {}\\r\\n sqlArray[self.deviceDescr][self.devNumber][\\\"General\\\"] = result\\r\\n sqlArray[self.deviceDescr][self.devNumber][\\\"_ExtractInfo\\\"] = {}\\r\\n sqlArray[self.deviceDescr][self.devNumber][\\\"_ExtractInfo\\\"][\\\"ExtractTime\\\"] = time.time()\\r\\n sqlArray[\\\"ReadError\\\"] = False \\r\\n return sqlArray\\r\\n \\r\\n except Exception as e: \\r\\n self.log.printError(\\\"ERROR in Retreiving Seatel VSAT Data,%s Module Error\\\" % sys._getframe().f_code.co_name) \\r\\n self.log.printError( str(e))\\r\\n self.Error = True\\r\\n Extra[\\\"ReadError\\\"] = True\\r\\n return Extra\\r\\n else:\\r\\n self.log.printWarning(\\\"%s skipped due to previous failure\\\" % sys._getframe().f_code.co_name)\\r\\n return None\",\n \"def getAll(self):\\n # Get VT\\n self.getVT()\\n # Process VT data\\n self.processVT()\\n # Get reverse DNS\\n self.getRDNS()\\n # Get passivetotal\\n self.getPT()\\n # Get Geolocation\\n self.getGeo()\\n # Get Shodan\\n self.getShodan()\",\n \"def get_all_data(self):\\n\\t\\ttemp = self.get_temp()\\n\\t\\taccel = self.get_accel_data()\\n\\t\\tgyro = self.get_gyro_data()\\n\\t\\treturn [accel, gyro, temp]\",\n \"def get_enriched_user_raw_data(self):\\n _items_of_scenario = DataEnrichmentScenarioItem.objects.filter(scenario=self.scenario).order_by('order')\\n for _enhancement_item in _items_of_scenario:\\n _worker_model = _enhancement_item.worker\\n _worker_instance = None # Stays None until first needed\\n\\n for _type in range(len(RawData.DATA_TYPE)):\\n if len(self.raw_data_groups[_type]) > 0: # If there is data for this type\\n if not _worker_model.applicable_to or _worker_model.applicable_to == _type: # Whether worker is applicable to every type, or this type\\n if not _worker_instance:\\n _worker_instance = DataEnrichManager._instantiate_enrich_worker(_worker_model.worker_name)\\n _results = _worker_instance.enrich(self.raw_data_groups[_type], _type, _worker_model.compatible_with.all()) # Base class'es enrich function delegates the call to right function according to _type parameter\\n # Also sending the compatible providers, so it won't process them\\n if not _results:\\n continue\\n for i in range(len(_results)):\\n if _results[i] is not None: # If the worker processed this item\\n self.enriched_data_groups[_type][i].criteria.append(_worker_model.name)\\n self.enriched_data_groups[_type][i].multiplier.append(_enhancement_item.multiplier)\\n self.enriched_data_groups[_type][i].priority.append(_results[i])\\n\\n Log.debug('Enrich results: ' + str(self.enriched_data_groups))\\n for _layer in self.enriched_data_groups: # Merging layers of enrichment results\\n for _item in _layer:\\n _weight = sum(_item.multiplier)\\n if _weight > 0:\\n _weight += 0.0 # To make float division\\n _total = 0\\n if type(_item.priority) == float:\\n _total = _item.priority\\n else:\\n for i, _score in enumerate(_item.priority): # To calculate weighted priority (i.e. if total weight was 50 and total score was 35, then score will be 70)\\n _total += _score * (_item.multiplier[i] / _weight)\\n\\n _item.priority = _total\\n _item.criteria = ','.join(_item.criteria)\\n else: # There wasn't any enrichment for this data\\n _item.priority = 0\\n _item.criteria = 'No matching criteria'\\n return self._sort_by_priority()\",\n \"def get_video_data(self):\\n\\t\\tfeature_str = 'fdhh' if self.fdhh else 'pca'\\n\\t\\tif self.options.mode == 'test':\\n\\t\\t\\tfeature_path = (f'{self.feature_folder}_FD', f'train_test_{feature_str}.pic')\\n\\t\\telse:\\n\\t\\t\\tfeature_path = (f'{self.feature_folder}_FD', f'train_dev_{feature_str}.pic')\\n\\t\\t\\t\\n\\t\\t# Return saved features if exist:\\n\\t\\tif not self.options.save_features and os.path.exists(f'{feature_path[0]}/{feature_path[1]}'):\\n\\t\\t\\tX_train, X_test = load_from_file(f'{feature_path[0]}/{feature_path[1]}')\\n\\t\\telse:\\n\\t\\t\\tX_train, X_test = self.get_train_test()\\n\\t\\t\\t'''X_train, X_test = scale(X_train, X_test, scale_type='standard', axis=0, use_boxcox=True, boxcox_axis=0,\\n\\t\\t\\t use_pandas=True, verbose=self.options.verbose)'''\\n\\t\\t\\tX_train, X_test = scale(X_train, X_test, scale_type='minmax', axis=0, use_pandas=True,\\n\\t\\t\\t verbose=self.options.verbose)\\n\\t\\t\\tif self.fdhh:\\n\\t\\t\\t\\tif self.options.verbose:\\n\\t\\t\\t\\t\\tprint('Performing FDHH over train and test set...')\\n\\t\\t\\t\\tX_train = X_train.groupby(level=0).apply(self.FDHH)\\n\\t\\t\\t\\tX_test = X_test.groupby(level=0).apply(self.FDHH)\\n\\t\\t\\t\\tif self.options.verbose:\\n\\t\\t\\t\\t\\tprint(f'Sparsity in Train fdhh = {np.sum(X_train.values == 0) / X_train.size}')\\n\\t\\t\\t\\t\\tprint(f'Sparsity in Test fdhh = {np.sum(X_test.values == 0) / X_test.size}')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tX_train, X_test = self.video_pca(X_train, X_test)\\n\\t\\t\\t\\t\\n\\t\\tif self.options.save_features:\\n\\t\\t\\tsave_to_file(feature_path[0], feature_path[1], (X_train, X_test))\\n\\t\\t\\tself.options.save_features = False\\n\\t\\t\\n\\t\\tif not self.fdhh:\\n\\t\\t\\tX_train = self.split_videos(X_train)\\n\\t\\t\\tX_test = self.split_videos(X_test)\\n\\t\\t\\t\\n\\t\\treturn [X_train, X_test]\",\n \"def getAllSpectrumMeasurements(self): \\n return self.spectrum\",\n \"def collect(self):\\r\\n for idx_ds, ds in enumerate(self.datasets):\\r\\n # print \\\"collect() using ds = \\\", repr(ds)\\r\\n reader_rows = ds.dict_reader()\\r\\n for row in reader_rows:\\r\\n # print \\\"Collect: idx_ds=%d\\\" % idx_ds\\r\\n for summary in self.summaries:\\r\\n #Derive coords from the row for this summary\\r\\n coords=[]\\r\\n for sum_col in summary.columns:\\r\\n level = str(row[sum_col.name])\\r\\n if level is not None and level != \\\"None\\\": \\r\\n if level.find('.') != -1:\\r\\n # May be a float value with .0 ending to trim\\r\\n try:\\r\\n # If value is parsable as a float, and it \\r\\n # is an integer, represent it as an integer.\\r\\n flevel = float(level)\\r\\n # Strip a final .0 from the string.\\r\\n level = (\\r\\n str(int(flevel)) if flevel == int(flevel)\\r\\n else str(level))\\r\\n except:\\r\\n # Not a float, OK.\\r\\n pass\\r\\n else:\\r\\n level = \\\"\\\"\\r\\n coords.append(level)\\r\\n #print \\\"coords:\\\", repr(coords)\\r\\n #Register row data into this summary.\\r\\n cell = summary.cell(coords)\\r\\n #Future, along with ds_index, could also pass along \\r\\n # row's ordinal column values.\\r\\n # Note to self: rename accrue_row to accrue_row() \\r\\n # when get into eclipse env\\r\\n cell.entry.accrue_row(idx_ds)\",\n \"def get_data(self)->pd.DataFrame:\\n pass\",\n \"def samples(self):\\n pass\",\n \"def get_datasets_summary(rs):\\n\\n\\tif rs == \\\"rs1\\\":\\n\\t\\tdataset_list = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT * FROM datasets WHERE dataset NOT LIKE 'CEMBA_RS2_%%'\\\").fetchall()\\n\\t\\tdataset_list += db.get_engine(current_app, 'snATAC_data').execute(\\\"SELECT * FROM datasets WHERE dataset NOT LIKE 'CEMBA_RS2_%%'\\\").fetchall()\\n\\n\\t\\t# This is a hack to get unique values in a list of dictionaries\\n\\t\\tdataset_list = list({x['dataset']:x for x in dataset_list}.values());\\n\\t\\ttotal_methylation_cell_each_dataset = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT dataset, COUNT(*) as `num` FROM cells WHERE dataset NOT LIKE 'CEMBA_RS2_%%' GROUP BY dataset\\\").fetchall()\\n\\t\\ttotal_snATAC_cell_each_dataset = db.get_engine(current_app, 'snATAC_data').execute(\\\"SELECT dataset, COUNT(*) as `num` FROM cells WHERE dataset NOT LIKE 'CEMBA_RS2_%%' GROUP BY dataset\\\").fetchall()\\n\\telif rs == \\\"rs2\\\":\\n\\t\\tdataset_list = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT * FROM datasets WHERE dataset LIKE 'CEMBA_RS2_%%'\\\").fetchall()\\n\\t\\ttotal_methylation_cell_each_dataset = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT dataset, COUNT(*) as `num` FROM cells WHERE dataset LIKE 'CEMBA_RS2_%%' GROUP BY dataset\\\").fetchall()\\n\\t\\ttotal_snATAC_cell_each_dataset = db.get_engine(current_app, 'snATAC_data').execute(\\\"SELECT dataset, COUNT(*) as `num` FROM cells WHERE dataset LIKE 'CEMBA_RS2_%%' GROUP BY dataset\\\").fetchall()\\n\\telif rs == \\\"all\\\":\\n\\t\\tdataset_list = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT * FROM datasets\\\").fetchall()\\n\\t\\tdataset_list += db.get_engine(current_app, 'snATAC_data').execute(\\\"SELECT * FROM datasets\\\").fetchall()\\n\\t\\t# This is a hack to get unique values in a list of dictionaries\\n\\t\\tdataset_list = list({x['dataset']:x for x in dataset_list}.values());\\n\\t\\ttotal_methylation_cell_each_dataset = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT dataset, COUNT(*) as `num` FROM cells GROUP BY dataset\\\").fetchall()\\n\\t\\ttotal_snATAC_cell_each_dataset = db.get_engine(current_app, 'snATAC_data').execute(\\\"SELECT dataset, COUNT(*) as `num` FROM cells GROUP BY dataset\\\").fetchall()\\n\\telse:\\n\\t\\treturn\\n\\n\\ttotal_methylation_cell_each_dataset = [ {d['dataset']: d['num']} for d in total_methylation_cell_each_dataset ]\\n\\ttotal_methylation_cell_each_dataset = { k: v for d in total_methylation_cell_each_dataset for k, v in d.items() }\\n\\ttotal_snATAC_cell_each_dataset = [ {d['dataset']: d['num']} for d in total_snATAC_cell_each_dataset ]\\n\\ttotal_snATAC_cell_each_dataset = { k: v for d in total_snATAC_cell_each_dataset for k, v in d.items() }\\n\\n\\tdataset_cell_counts = []\\n\\tfor dataset in dataset_list:\\n\\t\\ttry:\\n\\t\\t\\tnum_snATAC_cells = total_snATAC_cell_each_dataset[dataset['dataset']]\\n\\t\\texcept KeyError as e:\\n\\t\\t\\tnum_snATAC_cells = 0\\n\\n\\t\\tif \\\"RS2\\\" not in dataset['dataset']:\\n\\t\\t\\tbrain_region_code = dataset['dataset'].split('_')[1]\\n\\t\\t\\tresearch_segment = \\\"RS1\\\"\\n\\t\\telse:\\n\\t\\t\\tbrain_region_code = dataset['dataset'].split('_')[2]\\n\\t\\t\\tbrain_region_code = brain_region_code[-2:]\\n\\t\\t\\tresearch_segment = \\\"RS2\\\"\\n\\n\\t\\tregions_sql = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT ABA_description FROM ABA_regions WHERE ABA_acronym='%s'\\\" % dataset['brain_region']).fetchone()\\n\\t\\tif regions_sql is not None:\\n\\t\\t\\tABA_regions_descriptive = regions_sql['ABA_description'].replace('+', ', ')\\n\\t\\telse:\\n\\t\\t\\tABA_regions_descriptive = \\\"\\\"\\n\\n\\t\\tif rs == \\\"rs1\\\":\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tdataset_cell_counts.append( {\\\"dataset_name\\\": dataset['dataset'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"sex\\\": dataset['sex'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"methylation_cell_count\\\": total_methylation_cell_each_dataset[dataset['dataset']],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"snATAC_cell_count\\\": num_snATAC_cells,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ABA_regions_acronym\\\": dataset['brain_region'].replace('+', ', '),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ABA_regions_descriptive\\\": ABA_regions_descriptive,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"slice\\\": brain_region_code,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"date_added\\\": str(dataset['date_online']),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"description\\\": dataset['description'] })\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tdataset_cell_counts.append( {\\\"dataset_name\\\": dataset['dataset'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"sex\\\": dataset['sex'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"methylation_cell_count\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"snATAC_cell_count\\\": num_snATAC_cells,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ABA_regions_acronym\\\": dataset['brain_region'].replace('+', ', '),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ABA_regions_descriptive\\\": ABA_regions_descriptive,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"slice\\\": brain_region_code,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"date_added\\\": str(dataset['date_online']),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"description\\\": dataset['description'] })\\n\\t\\telse:\\n\\t\\t\\ttarget_region_sql = db.get_engine(current_app, 'methylation_data').execute(\\\"SELECT ABA_description FROM ABA_regions WHERE ABA_acronym='%s'\\\" % dataset['target_region']).fetchone()\\n\\t\\t\\tif target_region_sql is not None:\\n\\t\\t\\t\\ttarget_region_descriptive = target_region_sql['ABA_description'].replace('+', ', ')\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttarget_region_descriptive = \\\"\\\"\\n\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tdataset_cell_counts.append( {\\\"dataset_name\\\": dataset['dataset'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"research_segment\\\": research_segment,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"sex\\\": dataset['sex'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"methylation_cell_count\\\": total_methylation_cell_each_dataset[dataset['dataset']],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"snATAC_cell_count\\\": num_snATAC_cells,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ABA_regions_acronym\\\": dataset['brain_region'].replace('+', ', '),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ABA_regions_descriptive\\\": ABA_regions_descriptive,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"slice\\\": brain_region_code,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"date_added\\\": str(dataset['date_online']),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"description\\\": dataset['description'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"target_region_acronym\\\": dataset['target_region'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"target_region_descriptive\\\": target_region_descriptive})\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tdataset_cell_counts.append( {\\\"dataset_name\\\": dataset['dataset'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"research_segment\\\": research_segment,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"sex\\\": dataset['sex'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"methylation_cell_count\\\": 0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"snATAC_cell_count\\\": num_snATAC_cells,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ABA_regions_acronym\\\": dataset['brain_region'].replace('+', ', '),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"ABA_regions_descriptive\\\": ABA_regions_descriptive,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"slice\\\": brain_region_code,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"date_added\\\": str(dataset['date_online']),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"description\\\": dataset['description'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"target_region_acronym\\\": dataset['target_region'],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\\"target_region_descriptive\\\": target_region_descriptive})\\n\\n\\treturn json.dumps(dataset_cell_counts)\",\n \"def explore_data():\\n labels = [\\\"vehicles\\\", \\\"non-vehicles\\\"]\\n labelmap = {0: \\\"vehicles\\\", 1: \\\"non-vehicles\\\"}\\n vehicles_glob = os.path.join(data_dir, \\\"vehicles\\\", \\\"**\\\", \\\"*.png\\\")\\n nonvehicles_glob = os.path.join(data_dir, \\\"non-vehicles\\\", \\\"**\\\", \\\"*.png\\\")\\n class_fnames = [\\n glob.glob(vehicles_glob, recursive = True),\\n glob.glob(nonvehicles_glob, recursive = True)]\\n n_samples = [len(fnames) for fnames in class_fnames]\\n shapes = []\\n samples = []\\n print(table_format([\\\"label\\\", \\\"size\\\", \\\"shape\\\"], header = True))\\n for label, fnames in enumerate(class_fnames):\\n indices = np.random.choice(len(fnames), 4*10, replace = False)\\n for i in indices:\\n fname = fnames[i]\\n img = cv2.imread(fname)\\n samples.append(img)\\n shape = img.shape\\n shapes.append(shape)\\n print(table_format([labels[label], n_samples[label], shapes[label]]))\\n\\n samples = np.stack(samples)\\n samples = tile(samples, 2*4, 10)\\n cv2.imwrite(os.path.join(out_dir, \\\"datasamples.png\\\"), samples)\\n\\n return class_fnames, labelmap\",\n \"def _datasets(self):\\n return self._flat_data._datasets\",\n \"def get_datasets(load_key=None, maven=False):\\n ds_names = {}\\n if load_key == 'R2349': \\n ds_names['batsrus_mf_lr'] = model_dir+'R2349/batsrus_3d_multi_fluid_lowres.h5'\\n ds_names['batsrus_multi_species'] = model_dir+'R2349/batsrus_3d_multi_species.h5'\\n ds_names['batsrus_electron_pressure'] = model_dir+'R2349/batsrus_3d_pe.h5'\\n ds_names['heliosares'] ='/Volumes/triton/Data/ModelChallenge/R2349/heliosares_multi.h5'\\n #ds_names['rhybrid'] ='/Volumes/triton/Data/ModelChallenge/R2349/rhybrid.h5'\\n \\n ds_types = {'batsrus1':[key for key in ds_names.keys() if 'multi_fluid' in key],\\n 'batsrus2':[key for key in ds_names.keys() if 'multi_species' in key],\\n 'batsrus3':[key for key in ds_names.keys() if 'electron_pressure' in key],\\n 'batsrus4':[key for key in ds_names.keys() if 'mf_lr' in key],\\n 'heliosares':[key for key in ds_names.keys() if 'helio' in key],\\n 'rhybrid_helio':[key for key in ds_names.keys() if 'rhybrid' in key ]}\\n if maven or True:\\n ds_names['maven']=orbit_dir+'orbit_2349.csv'\\n #ds_names['maven'] = orbit_dir+'orbit_plume_2349.csv'\\n ds_types['maven']=['maven']\\n elif load_key == 'batsrus_mf_lowres':\\n ds_names['batsrus_mf_lr'] = model_dir+'R2349/batsrus_3d_multi_fluid_lowres.h5'\\n ds_types = {'batsrus_mf_lr' : ['batsrus_mf_lr']}\\n\\n\\n elif load_key == 'helio_multi':\\n ds_names['t00550'] = model_dir+'R2349/Heliosares_Multi/t00550.h5'\\n ds_names['t00560'] = model_dir+'R2349/Heliosares_Multi/t00560.h5'\\n ds_names['t00570'] = model_dir+'R2349/Heliosares_Multi/t00570.h5'\\n ds_names['t00580'] = model_dir+'R2349/Heliosares_Multi/t00580.h5'\\n ds_names['t00590'] = model_dir+'R2349/Heliosares_Multi/t00590.h5'\\n ds_names['t00600'] = model_dir+'R2349/Heliosares_Multi/t00600.h5'\\n ds_names['t00610'] = model_dir+'R2349/Heliosares_Multi/t00610.h5'\\n ds_names['t00620'] = model_dir+'R2349/Heliosares_Multi/t00620.h5'\\n ds_names['t00630'] = model_dir+'R2349/Heliosares_Multi/t00630.h5'\\n ds_names['t00640'] = model_dir+'R2349/Heliosares_Multi/t00640.h5'\\n ds_names['t00650'] = model_dir+'R2349/Heliosares_Multi/t00650.h5'\\n\\n ds_types = {'heliosares':[key for key in ds_names.keys()]}\\n if maven:\\n #ds_names['maven'] = orbit_dir+'orbit_2349.csv'\\n ds_types['maven']=['maven']\\n elif load_key == 'SDC_BATS':\\n ds_names['LS180_SSL000_max'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL000_max.h5'\\n ds_names['LS270_SSL000_max'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL000_max.h5'\\n ds_names['LS090_SSL000_max'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL000_max.h5'\\n ds_names['LS180_SSL270_max'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL270_max.h5'\\n ds_names['LS270_SSL270_max'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL270_max.h5'\\n ds_names['LS090_SSL270_max'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL270_max.h5'\\n ds_names['LS180_SSL180_max'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL180_max.h5'\\n ds_names['LS270_SSL180_max'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL180_max.h5'\\n ds_names['LS090_SSL180_max'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL180_max.h5'\\n ds_names['LS180_SSL000_min'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL000_min.h5'\\n ds_names['LS270_SSL000_min'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL000_min.h5'\\n ds_names['LS090_SSL000_min'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL000_min.h5'\\n ds_names['LS180_SSL270_min'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL270_min.h5'\\n ds_names['LS270_SSL270_min'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL270_min.h5'\\n ds_names['LS090_SSL270_min'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL270_min.h5'\\n ds_names['LS180_SSL180_min'] = model_dir+'SDC_Archive/BATSRUS/LS180_SSL180_min.h5'\\n ds_names['LS270_SSL180_min'] = model_dir+'SDC_Archive/BATSRUS/LS270_SSL180_min.h5'\\n ds_names['LS090_SSL180_min'] = model_dir+'SDC_Archive/BATSRUS/LS090_SSL180_min.h5'\\n\\n ds_types = {'batsrus':[key for key in ds_names.keys()]}\\n\\n elif load_key == 'SDC_G1':\\n #BATSRUS\\n ds_names['bats_min_LS270_SSL0'] = \\\\\\n model_dir+'SDC_Archive/BATSRUS/'+'3d__ful_4_n00060000_PERmin-SSLONG0.h5'\\n ds_names['bats_min_LS270_SSL180'] = \\\\\\n model_dir+'SDC_Archive/BATSRUS/'+'3d__ful_4_n00060000_PERmin-SSLONG180.h5'\\n ds_names['bats_min_LS270_SSL270'] = \\\\\\n model_dir+'SDC_Archive/BATSRUS/'+'3d__ful_4_n00060000_PERmin-SSLONG270.h5' \\n \\n #HELIOSARES\\n #ds_names['helio_1'] = \\\\\\n # model_dir+'SDC_Archive/HELIOSARES/Hybrid/'+'helio_1.h5'\\n \\n #ds_names['helio_2'] = \\\\\\n # model_dir+'SDC_Archive/HELIOSARES/Hybrid/'+'helio_2.h5'\\n \\n \\n ds_types = {'batsrus1':[key for key in ds_names.keys() if 'bats' in key],\\n 'heliosares':[key for key in ds_names.keys() if 'helio' in key]}\\n if maven:\\n pass\\n #ds_names['maven'] = orbit_dir+'orbit_2349.csv'\\n #ds_types['maven']=['maven']\\n\\n elif load_key == 'rhybrid_res':\\n ds_names = {'rhybrid240':'/Volumes/triton/Data/ModelChallenge/R2349/rhybrid.h5',\\n 'rhybrid120':'/Volumes/triton/Data/ModelChallenge/R2349/HYB/state00030000.h5'}\\n ds_types = {'rhybrid1':['rhybrid240'], 'rhybrid2':['rhybrid120']}\\n elif load_key == 'batsrus_tseries':\\n ds_names = {'batsrus_mf':'/Volumes/triton/Data/ModelChallenge/R2349/BATSRUS/10km_mf/3d__ful_4_n00040000.h5',\\n 'batsrus_ms':'/Volumes/triton/Data/ModelChallenge/R2349/BATSRUS/10km_ms/3d__mhd_6_n0050000.h5'}\\n ds_types = {'batsrus_mf':['batsrus_mf'], 'batsrus_ms':['batsrus_ms']}\\n\\n elif load_key == 'maven':\\n ds_names, ds_types = {},{}\\n ds_names['maven'] = orbit_dir+'orbit_2349.csv'\\n ds_types['maven']=['maven']\\n elif load_key == 'exo_2349':\\n keys = ['2349_1RM_225km','2349_1RM_450km', '2349_2RM_450km',\\n '2349_2RM_900km','2349_4RM_900km'] \\n ds_names = {k:exo_dir+'/'+k+'/'+k+'.h5' for k in keys}\\n ds_types = {k:[k] for k in keys}\\n elif load_key == 'exo_comparisonA':\\n keys = ['2349_1RM_225km', '2349_2RM_450km',\\n '2349_1.5RM_338km'] \\n ds_names = {k:exo_dir+'/ComparisonA/'+k+'.h5' for k in keys}\\n ds_types = {k:[k] for k in keys}\\n elif load_key == 'exo_comparisonB':\\n keys = ['2349_1RM_225km', 'T0_1RM_225km', 'T1_1RM_225km', \\\"T2_1RM_225km\\\"] \\n ds_names = {k:exo_dir+'/ComparisonB/'+k+'.h5' for k in keys}\\n ds_types = {k:[k] for k in keys}\\n\\n elif load_key == 'exo_t1':\\n keys = ['T1_1RM_112km', 'T1_1RM_225km', #'T1_1RM_450km',\\n 'T1_2RM_225km', 'T1_2RM_450km', #'T1_2RM_900km',\\n 'T1_4RM_900km']\\n\\n ds_names = {k:exo_dir+'/'+k+'/'+k+'.h5' for k in keys}\\n ds_types = {k:[k] for k in keys}\\n\\n else:\\n print('No datasets selected')\\n \\n\\n return (ds_names, ds_types)\",\n \"def load_data(self):\",\n \"def all_experiments():\\n elo_explain_experiments()\\n alpha_beta_experiments()\\n mtcs_experiments()\",\n \"def populate_data(self):\\r\\n # Importing StationData with the standard imports causes a redundancy\\r\\n # problem, so it is imported here only when it is needed.\\r\\n from stationData import StationData\\r\\n # Find data requirements from all plumes.\\r\\n requirements = describe.PLUMES\\r\\n # Loop over plumes and define parameters to be used for pulling data.\\r\\n grib_file = pygrib.open(self.grib_file_path)\\r\\n for req in requirements:\\r\\n (plume,data_types,grid_level_type,grid_level,unused) = req\\r\\n selected = grib_file.select(shortName=data_types,\\r\\n typeOfLevel=grid_level_type,\\r\\n level=grid_level)\\r\\n for i, message in enumerate(selected):\\r\\n if i % 20 == 0:\\r\\n print '%s %s/%s Grib messages processed for %s' %\\\\\\r\\n (PRETEXT, i + 1, len(selected), req[0])\\r\\n for sdo in StationData.instances:\\r\\n if sdo.grib_i is None:\\r\\n StationData.populate_grid_information(message,\\r\\n self.config)\\r\\n sdo.add_data(plume,self.member_name,message)\\r\\n grib_file.close()\\r\\n return\",\n \"def get_all(self):\\n self.data = list(self.data)\\n return self.data\",\n \"def get_data_experimentIDAndTimePointAndUnits_dataStage02GlogNormalized(self, experiment_id_I,time_point_I,concentration_units_I):\\n #Tested\\n try:\\n data = self.session.query(data_stage02_quantification_glogNormalized.experiment_id,\\n data_stage02_quantification_glogNormalized.sample_name_short,\\n data_stage02_quantification_glogNormalized.time_point,\\n data_stage02_quantification_glogNormalized.component_group_name,\\n data_stage02_quantification_glogNormalized.component_name,\\n data_stage02_quantification_glogNormalized.calculated_concentration,\\n data_stage02_quantification_glogNormalized.calculated_concentration_units).filter(\\n data_stage02_quantification_glogNormalized.experiment_id.like(experiment_id_I),\\n data_stage02_quantification_glogNormalized.time_point.like(time_point_I),\\n data_stage02_quantification_glogNormalized.calculated_concentration_units.like(concentration_units_I),\\n data_stage02_quantification_glogNormalized.used_.is_(True)).group_by(\\n data_stage02_quantification_glogNormalized.experiment_id,\\n data_stage02_quantification_glogNormalized.sample_name_short,\\n data_stage02_quantification_glogNormalized.time_point,\\n data_stage02_quantification_glogNormalized.component_group_name,\\n data_stage02_quantification_glogNormalized.component_name,\\n data_stage02_quantification_glogNormalized.calculated_concentration,\\n data_stage02_quantification_glogNormalized.calculated_concentration_units).all();\\n data_O = [];\\n for d in data: \\n data_1 = {};\\n data_1['experiment_id'] = d.experiment_id;\\n data_1['sample_name_short'] = d.sample_name_short;\\n data_1['time_point'] = d.time_point;\\n data_1['component_group_name'] = d.component_group_name;\\n data_1['component_name'] = d.component_name;\\n data_1['calculated_concentration'] = d.calculated_concentration;\\n data_1['calculated_concentration_units'] = d.calculated_concentration_units;\\n data_O.append(data_1);\\n return data_O;\\n except SQLAlchemyError as e:\\n print(e);\",\n \"def _extract_all(sel,\\n rootpath=r'D:\\\\WorkStation_2018\\\\WorkStation_dynamicFC\\\\Workstation_dynamic_fc_baobaoComputer\\\\Data\\\\Dynamic',\\n whichstate='state1'):\\n\\n # hc\\n group_name = 'HC'\\n data_hc = sel._extract_one(rootpath, whichstate, group_name)\\n\\n # mdd\\n group_name = 'MDD'\\n data_mdd = sel._extract_one(rootpath, whichstate, group_name)\\n\\n # bd\\n group_name = 'BD'\\n data_bd = sel._extract_one(rootpath, whichstate, group_name)\\n\\n # sz\\n group_name = 'SZ'\\n data_sz = sel._extract_one(rootpath, whichstate, group_name)\\n\\n # concat\\n data_all = pd.concat([data_hc, data_mdd, data_bd, data_sz], axis=0)\\n data_all.index = np.arange(0, np.shape(data_all)[0])\\n\\n return data_all\",\n \"def get_data():\\n\\n size, intensity, age = [], [], []\\n def calculate(data, data_top):\\n \\\"\\\"\\\"Return age and the averages of size and intensity.\\\"\\\"\\\"\\n size, intensity, age = np.array([data[\\\"Size\\\"]]), np.array([data[\\\"Intensity\\\"]]), data_top.iat[1,0]\\n size_avg, intensity_avg = np.average(size), np.average(intensity)\\n return size_avg, intensity_avg, age\\n \\n with os.scandir(\\\"imgdata/\\\") as files:\\n for entry in files:\\n data = pd.read_csv(entry, header=3, index_col=0)\\n data_top = pd.read_csv(entry, index_col=0, nrows=2, header=None)\\n result = calculate(data, data_top)\\n size.append(result[0])\\n intensity.append(result[1])\\n age.append(result[2])\\n return size, intensity, age\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62828743","0.626822","0.6251617","0.62077177","0.6118616","0.608259","0.60632056","0.6046632","0.6015187","0.6005819","0.6002392","0.5981022","0.5975537","0.594545","0.59365","0.5932329","0.5926135","0.592105","0.5919021","0.58763653","0.58556014","0.58478194","0.5832243","0.58282596","0.5820368","0.58149314","0.57934964","0.579308","0.577953","0.5778153","0.5775258","0.5775193","0.57661855","0.5762876","0.5757826","0.57554924","0.57480824","0.5747718","0.573763","0.5736633","0.5733173","0.5720156","0.57176095","0.57017714","0.5700373","0.56962013","0.56923836","0.56784207","0.5660188","0.5660188","0.5659588","0.5658931","0.5652606","0.56498927","0.5648418","0.5647032","0.56447196","0.5641916","0.5641601","0.5638801","0.5628175","0.5622695","0.56217515","0.56188184","0.5615901","0.56090766","0.5608082","0.56078595","0.5594125","0.5590711","0.5588885","0.5587072","0.55869097","0.5585848","0.558034","0.55797935","0.557388","0.5571194","0.5567346","0.5567194","0.5565141","0.55630416","0.5561819","0.5559915","0.55587834","0.5553686","0.5543574","0.55428994","0.55393404","0.55374694","0.55306107","0.55269456","0.5519441","0.5516431","0.5514852","0.55040914","0.54970896","0.54965204","0.5489283","0.54856163"],"string":"[\n \"0.62828743\",\n \"0.626822\",\n \"0.6251617\",\n \"0.62077177\",\n \"0.6118616\",\n \"0.608259\",\n \"0.60632056\",\n \"0.6046632\",\n \"0.6015187\",\n \"0.6005819\",\n \"0.6002392\",\n \"0.5981022\",\n \"0.5975537\",\n \"0.594545\",\n \"0.59365\",\n \"0.5932329\",\n \"0.5926135\",\n \"0.592105\",\n \"0.5919021\",\n \"0.58763653\",\n \"0.58556014\",\n \"0.58478194\",\n \"0.5832243\",\n \"0.58282596\",\n \"0.5820368\",\n \"0.58149314\",\n \"0.57934964\",\n \"0.579308\",\n \"0.577953\",\n \"0.5778153\",\n \"0.5775258\",\n \"0.5775193\",\n \"0.57661855\",\n \"0.5762876\",\n \"0.5757826\",\n \"0.57554924\",\n \"0.57480824\",\n \"0.5747718\",\n \"0.573763\",\n \"0.5736633\",\n \"0.5733173\",\n \"0.5720156\",\n \"0.57176095\",\n \"0.57017714\",\n \"0.5700373\",\n \"0.56962013\",\n \"0.56923836\",\n \"0.56784207\",\n \"0.5660188\",\n \"0.5660188\",\n \"0.5659588\",\n \"0.5658931\",\n \"0.5652606\",\n \"0.56498927\",\n \"0.5648418\",\n \"0.5647032\",\n \"0.56447196\",\n \"0.5641916\",\n \"0.5641601\",\n \"0.5638801\",\n \"0.5628175\",\n \"0.5622695\",\n \"0.56217515\",\n \"0.56188184\",\n \"0.5615901\",\n \"0.56090766\",\n \"0.5608082\",\n \"0.56078595\",\n \"0.5594125\",\n \"0.5590711\",\n \"0.5588885\",\n \"0.5587072\",\n \"0.55869097\",\n \"0.5585848\",\n \"0.558034\",\n \"0.55797935\",\n \"0.557388\",\n \"0.5571194\",\n \"0.5567346\",\n \"0.5567194\",\n \"0.5565141\",\n \"0.55630416\",\n \"0.5561819\",\n \"0.5559915\",\n \"0.55587834\",\n \"0.5553686\",\n \"0.5543574\",\n \"0.55428994\",\n \"0.55393404\",\n \"0.55374694\",\n \"0.55306107\",\n \"0.55269456\",\n \"0.5519441\",\n \"0.5516431\",\n \"0.5514852\",\n \"0.55040914\",\n \"0.54970896\",\n \"0.54965204\",\n \"0.5489283\",\n \"0.54856163\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56952274"},"document_rank":{"kind":"string","value":"46"}}},{"rowIdx":12887,"cells":{"query":{"kind":"string","value":"Get a subset of the design. A nice method but not actually used elsewhere."},"document":{"kind":"string","value":"def get(self, query):\n\n if not isinstance(query, dict):\n raise ValueError('Query should be a python dict')\n\n ##set default query containing all values\n default_query = {\n 'cell_id': self.cell_id,\n 'treatment': self.treatments,\n 'time_point': self.time_points,\n 'replicate': self.replicates\n }\n default_query.update(query)\n\n for k, v in list(query.items()):\n if not isinstance(v, list):\n query[k] = [v]\n\n\n available_labels = ['treatment', 'cell_id', 'time_point', 'replicate']\n\n\n labels = list(default_query.keys())\n if len(labels) not in list(range(1, 5)):\n raise ValueError('labels must be a list of length 1, 2, 3, or 4')\n\n for label in labels:\n if label not in available_labels:\n raise ValueError('\"{}\" not in accepted list of labels. These are '\n 'accepted \"{}\"'.format(label, available_labels))\n\n\n if label is 'cell_id':\n cell_id_query = reduce(\n lambda x, y: \"{} or {}\".format(x, y),\n ['cell_id == \"{}\"'.format(i) for i in default_query[label]]\n )\n if label is 'treatment':\n treatment_query = reduce(\n lambda x, y: \"{} or {}\".format(x, y),\n ['treatment == \"{}\"'.format(i) for i in default_query[label]]\n )\n\n if label is 'time_point':\n time_query = reduce(\n lambda x, y: \"{} or {}\".format(x, y),\n ['time_point == {}'.format(i) for i in default_query[label]]\n )\n\n if label is 'replicate':\n replicate_query = reduce(\n lambda x, y: \"{} or {}\".format(x, y),\n ['replicate == {}'.format(i) for i in default_query[label]]\n )\n\n final_query = \"({}) and ({}) and ({}) and ({})\".format(\n cell_id_query, replicate_query, treatment_query,\n time_query\n )\n df = self.design.query(final_query)\n return self.data[self.data['Sample'].isin(df['Sample'])]"},"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_designs(self):","def subset(\n self, \n include: Union[Sequence[Any], Any] = None, \n exclude: Union[Sequence[Any], Any] = None) -> Bunch:\n pass","def default_subset(self):\n\t\treturn [slice(0,dim.length) for dim in self.variable.dimensions]","def get_subset(self, name):\n assert name in ['train', 'valid', 'test'], f'Invalid dataset name! {name} has been provided but must be one of [train, valid, test]'\n return self.subsets[name]","def subset_(self):\n return self.X.ix[:, self.important_features_]","def internalSubset(self, name, externalID, systemID):\n pass","def get_subset_list(self):\n\n return self.subset_list","def test_general_subset_dset():\n pass","def _make_subset(cls, name, data, **kwargs):\r\n return cls(name, data, **kwargs)","def test_general_subset_all():\n pass","def _subset(self, idxs):\n vertices = [self.vertices[i] for i in idxs]\n if hasattr(self, \"data\"):\n data = Table(data=[self.data._data[i] for i in idxs], fields=self.data.fields)\n return type(self)(vertices, properties=self.properties, data=data, crs=self.crs)\n else:\n return type(self)(vertices, properties=self.properties, crs=self.crs)","def _getSubset(self, label):\n\n if self._flags is None:\n self._flags = {}\n self._subsets = {}\n elif flags.TIMESTAMP != self._flagsts:\n self._resetFlags()\n self._flagsts = flags.TIMESTAMP\n\n try:\n return self._subsets[label]\n except KeyError:\n flgs = self._getFlags(label)\n try:\n return self._subsets[label]\n except KeyError:\n indices = flgs.nonzero()[0]\n self._setSubset(label, indices)\n return indices.copy()","def subsetter(self, font, subset):\n options = Options()\n options.layout_features = \"*\" # keep all GSUB/GPOS features\n # options.no_layout_closure = True # TESTING\n options.glyph_names = False # keep post glyph names\n options.legacy_cmap = True # keep non-Unicode cmaps\n options.name_legacy = True # keep non-Unicode names\n options.name_IDs = [\"*\"] # keep all nameIDs\n options.name_languages = [\"*\"] # keep all name languages\n options.notdef_outline = False\n options.ignore_missing_glyphs = True\n options.prune_unicode_ranges = True\n options.recommended_glyphs = True\n subsetter = Subsetter(options=options)\n subsetter.populate(glyphs=subset)\n subsetter.subset(font)\n\n return font","def pulledsubset(self):\n # compute target subset\n if self.heads is None:\n # We pulled every thing possible\n # sync on everything common\n c = set(self.common)\n ret = list(self.common)\n for n in self.rheads:\n if n not in c:\n ret.append(n)\n return ret\n else:\n # We pulled a specific subset\n # sync on this subset\n return self.heads","def get_subset(self, start=None, end=None):\n \n if start is None and end is None:\n return self.img_lst\n elif start is None:\n return self.img_lst[:end]\n elif end is None:\n return self.img_lst[start:]\n else:\n return self.img_lst[start:end]","def is_subset(self, other):","def Get(self,k:int): \n ### get partitions depending on the partition schemes C that depends on k!\n return subsets_k(list(range(self._n)),k)","def _subset(self, idxs):\n vertices = [self.vertices[i] for i in idxs]\n subset = Line(vertices, properties=self.properties, crs=self.crs)\n return subset","def design(self):\n return self[self.design_columns]","def design(self):\n return self[self.design_columns]","def get_uniform_subset(self, samples_per_label):\n raise NotImplementedError","def externalSubset(self, name, externalID, systemID):\n pass","def test_general_subset_level():\n pass","def __getslice__(self, start, stop):\n return self.__getitem__(slice(start, stop, None))","def get_subset_rt(self, rt):\n regions = self.boxes_rt.at(rt)\n it = BoxHolder()\n for r in regions:\n box = r.data\n it.add_box(box)\n return it","def test_general_subset_space():\n pass","def build_subsets(self):\n self.all = nrn.SectionList()\n self.all.wholetree(sec=self.soma)","def get_data_subset(selection, network_type='drive', infrastructure='way[\"highway\"]'):\n paths = []\n nodes = []\n if infrastructure == 'node[\"highway\"]':\n nodes = [n for n in selection[0]['elements'] if n['type'] == 'node' and 'tags' in n and 'highway' in n['tags']]\n else:\n paths = [p for p in selection[0]['elements'] if p['type'] == 'way'\n and check_infrastructure(infrastructure, p)\n and check_network(network_type, p)\n ]\n\n if not nodes:\n node_ids = []\n for p in paths:\n if 'nodes' not in p:\n continue\n node_ids.extend(p['nodes'])\n\n nodes = [n for n in selection[0]['elements'] if n['id'] in node_ids]\n\n return [{'version': selection[0]['version'],\n 'osm3s': selection[0]['osm3s'],\n 'generator': selection[0]['generator'],\n 'bounds': selection[0]['bounds'],\n 'elements': paths + nodes\n }\n ]","def getslice(self, *args, **kwargs):\n return _image.image_getslice(self, *args, **kwargs)","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 all(self, name, codes):\n if self.is_array(name):\n logics = []\n for s in self.sources(name):\n logics.append({s: has_all(codes)})\n slicer = self.take(intersection(logics))\n else:\n slicer = self.take({name: has_all(codes)})\n return slicer","def api_subset_lookup(cur):\n if 'api_subset' not in _tables:\n rclass = rclass_id_lookup(cur)\n _tables['api_subset'] = dict((k, rclass[v]) for k, v in API_SUBSETS.items())\n return _tables['api_subset']","def sub_set(self, idcs):\n return SubSet(dset=self, idcs=idcs)","def getSlice(properties=None, **kw):","def select_fits_subset(self, pre_processing=None, binning=None,\n exposure=(None, 'max'), reduction=None,\n observatory=None, jd=(None, 'exact')):\n self.data_subset = self.all_data.copy()\n\n # Select on pre-processing if provided.\n if pre_processing:\n self.data_subset = self.data_subset.loc[\n self.data_subset['PreProcessing'] == pre_processing]\n\n # Select on binning if provided.\n if binning:\n self.data_subset = self.data_subset.loc[\n self.data_subset['Binning'] == binning]\n\n # Select on exposure if provided.\n if exposure[0]:\n if exposure[1] == 'exact':\n self.data_subset = self.data_subset.loc[\n self.data_subset['Exposure'] == exposure[0]]\n elif exposure[1] == 'min':\n self.data_subset = self.data_subset.loc[\n self.data_subset['Exposure'] > exposure[0]]\n elif exposure[1] == 'max':\n self.data_subset = self.data_subset.loc[\n self.data_subset['Exposure'] < exposure[0]]\n elif exposure[1] == 'between':\n self.data_subset = self.data_subset.loc[\n (self.data_subset['Exposure'] > exposure[0][0]) &\n (self.data_subset['Exposure'] < exposure[0][1])]\n\n # Select on reduction if provided.\n if reduction:\n self.data_subset = self.data_subset.loc[\n self.data_subset['Reduction'] == reduction]\n\n # Select on observatory if provided.\n if observatory:\n self.data_subset = self.data_subset.loc[\n self.data_subset['Observatory'] == observatory]\n\n # Select on jd if provided.\n if jd[0]:\n if jd[1] == 'exact':\n if isinstance(jd[0], list):\n self.data_subset = self.data_subset.loc[\n self.data_subset['JD'].isin(jd[0])]\n else:\n self.data_subset = self.data_subset.loc[\n self.data_subset['JD'] == jd[0]]\n elif jd[1] == 'except':\n if isinstance(jd[0], list):\n self.data_subset = self.data_subset.drop(\n self.data_subset[self.data_subset[\n 'JD'].isin(jd[0])].index)\n else:\n self.data_subset = self.data_subset.drop(\n self.data_subset[self.data_subset['JD']\n == jd[0]].index)\n elif jd[1] == 'after':\n self.data_subset = self.data_subset.loc[\n self.data_subset['JD'] > jd[0]]\n elif jd[1] == 'before':\n self.data_subset = self.data_subset.loc[\n self.data_subset['JD'] < jd[0]]\n elif jd[1] == 'between':\n self.data_subset = self.data_subset.loc[\n (self.data_subset['JD'] > jd[0][0]) &\n (self.data_subset['JD'] < jd[0][1])]\n\n # Sort by JD and reset index.\n self.data_subset = self.data_subset.sort_values(\n by=['JD'], ascending=True).reset_index(drop=True)\n\n # Check spectra found:\n if len(self.data_subset) == 0:\n raise FileExistsError(\n 'No spectra found for that location or subset.')\n\n print('Selecting {} spectra from fits dataset.'.format(\n len(self.data_subset)))","def extract_subset(self, subset):\n \n # note subsets have an unusual encoding\n query = \"\"\"\n prefix oboInOwl: <http://www.geneontology.org/formats/oboInOwl#>\n SELECT ?c WHERE {{\n GRAPH <{g}> {{\n ?c oboInOwl:inSubset ?s\n FILTER regex(?s,'#{s}$','i')\n }}\n }}\n \"\"\".format(s=subset, g=self.graph_name)\n bindings = run_sparql(query)\n return [r['c']['value'] for r in bindings]","def feature_subset(self,node,db,labels,ids):\n return None","def getSets():","def subsets(self):\n \n # note subsets have an unusual encoding\n query = \"\"\"\n prefix oboInOwl: <http://www.geneontology.org/formats/oboInOwl#>\n SELECT DISTINCT ?s WHERE {{\n GRAPH <{g}> {{\n ?c oboInOwl:inSubset ?s \n }}\n }}\n \"\"\".format(g=self.graph_name)\n bindings = run_sparql(query)\n return [r['s']['value'] for r in bindings]","def subset(self,n):\n\n if n>=len(self):\n\n warning.warn(f\"\"\" SweepParam.subset : {n} larger than SweepParam length ({len(self)})\"\"\")\n\n return self\n\n from numpy import ceil\n\n if len(self)%2==1:\n\n spacing=int(floor((len(self)+1)/n))\n\n else:\n\n spacing=int(floor(len(self)/n))\n\n new_dict={}\n\n for name in self.names:\n\n old_values=self._dict[name]\n\n new_values=[old_values[x] for x in range(0,len(self)-1,spacing)]\n\n if not len(new_values)==n:\n\n import pdb; pdb.set_trace()\n raise ValueError(\"bug in subset creation, wrong length\")\n\n else:\n\n new_dict[name]=new_values\n\n return SweepParam(new_dict)","def __iter__(self):\r\n if self._shuffle:\r\n perm = torch.randperm(self._subset_size)\r\n return iter(self._subset[perm].tolist())\r\n return iter(self._subset)","def getSubsets(cityIndicesExcluding1, subsetSizeWithout1):\r\n\r\n # Getting subsets of specific size excluding start vertex, i.e.,city 1 and without the city 1\r\n subsets = []\r\n X = list( itertools.combinations(cityIndicesExcluding1, subsetSizeWithout1) )\r\n\r\n # Appending start vertex, i.e., city 1 to each subset\r\n for x in X:\r\n x = ( 1, ) + x\r\n subsets.append( x )\r\n\r\n return subsets","def check_subset(P1,P2,k=-1):","def test_get_software_set_expanded(self):\n pass","def ifc_subsets(me, ifc):\n return me._ifc_subs.get(ifc, frozenset())","def test_query_subset_response_AdventureWorks2014(self):\n\n with open(self.get_test_baseline(u'select_from_humanresources_department_adventureworks2014.txt'), u'r+b', buffering=0) as response_file:\n request_stream = io.BytesIO()\n rpc_client = json_rpc_client.JsonRpcClient(\n request_stream, response_file)\n rpc_client.start()\n # Submit a dummy request.\n parameters = {u'OwnerUri': u'connectionservicetest',\n u'BatchIndex': 0,\n u'ResultSetIndex': 0,\n u'RowsStartIndex': 0,\n u'RowCount': 16}\n\n request = queryservice.QuerySubsetRequest(\n 3, rpc_client, parameters)\n self.verify_subset_response(request=request)\n rpc_client.shutdown()","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 test_general_subset_invalid_level():\n pass","def subsets(self):\n return set(self.subset_map.values())","def get_slice(self, sim):\n # TODO: This function is definitely not general. We need to get a list\n # of layers to exclude from the user. For now, just assume we want to\n # exclude the top and bottom regions\n # sorted_layers is an OrderedDict, and thus has the popitem method\n sorted_layers = sim.conf.sorted_dict(sim.conf['Layers'])\n first_layer = sorted_layers.popitem(last=False)\n last_layer = sorted_layers.popitem()\n # We can get the starting and ending planes from their heights\n start_plane = int(round(first_layer[1]['params'][\n 'thickness'] / sim.dz))\n end_plane = int(round(last_layer[1]['params'][\n 'thickness'] / sim.dz))\n return start_plane, end_plane","def set_subset(self):\r\n if self._random_subset:\r\n perm = torch.randperm(len(self._indices))\r\n self._subset = self._indices[perm][:self._subset_size]\r\n else:\r\n self._subset = torch.Tensor(self._indices[:self._subset_size])","def get_subset(df, constraints):\n for constraint in constraints:\n subset = df.loc[df[constraint[0]].isin(constraint[1])]\n df = subset\n return subset","def select(self):\n return self.recipeset","def __getitem__(self,key):\n if type(key) is types.SliceType: #Or can use 'try:' for speed\n return FeatureSet(list.__getitem__(self, key))\n else:\n return list.__getitem__(self,key)","def request_subset_list(self, request):\n user_id = request['user_id']\n workspace_uuid = request['workspace_uuid'] \n \n # Initiate structure \n response = {'workspace': {}, \n 'subsets': []}\n \n # Add workspace info\n response['workspace'] = self.dict_workspace(unique_id=workspace_uuid, user_id=user_id)\n \n subset_list = self.list_subsets(workspace_unique_id=workspace_uuid, user_id=user_id)\n \n # Add subset info \n response['subsets'] = subset_list\n \n return response","def extract_subset_idx(self, start_idx, end_idx):\r\n templist = ChannelList()\r\n # Burris and Scintrex have different fields. This only returns non-empty fields.\r\n for field, value in self:\r\n temp = value[start_idx : end_idx + 1]\r\n setattr(templist, field, temp)\r\n return templist","def dict_subset(self, workspace_unique_id=None, subset_unique_id=None, request=None):\n workspace_object = self._get_workspace_object(unique_id=workspace_unique_id)\n \n subset_dict = {'alias': None,\n 'uuid': None,\n 'status': None,\n 'active': None,\n 'time': {}, \n 'periods': [], # Should be removed\n 'water_bodies': [], \n 'water_districts': [], \n 'supporting_elements': [], \n 'quality_elements': []}\n \n # Check request \n if request:\n if request['active']:\n workspace_object.uuid_mapping.set_active(subset_unique_id)\n else:\n workspace_object.uuid_mapping.set_inactive(subset_unique_id)\n\n else:\n subset_dict['alias'] = workspace_object.uuid_mapping.get_alias(subset_unique_id, status=self.all_status) \n subset_dict['uuid'] = subset_unique_id\n subset_dict['status'] = workspace_object.uuid_mapping.get_status(unique_id=subset_unique_id) \n subset_dict['active'] = workspace_object.uuid_mapping.is_active(unique_id=subset_unique_id)\n \n subset_dict = {'time': {}, \n 'periods': [], # Should be removed\n 'water_bodies': [], \n 'water_districts': [], \n 'supporting_elements': [], \n 'quality_elements': []}\n \n if request == None: \n request = {}\n \n \n # Time\n subset_dict['time'] = self.dict_time(workspace_unique_id=workspace_unique_id, \n subset_unique_id=subset_unique_id, \n request=request.get('time', {}))\n \n # Deprecated list for periods\n subset_dict['periods'] = self.list_periods(workspace_unique_id=workspace_unique_id, \n subset_unique_id=subset_unique_id, \n request=request.get('periods', {}))\n \n \n # Areas (contains water_district, type_area and water_body in a tree structure) \n subset_dict['areas'] = self.list_areas(workspace_unique_id=workspace_unique_id, \n subset_unique_id=subset_unique_id, \n request=request.get('areas', {}))\n \n # Quality elements \n subset_dict['quality_elements'] = self.list_quality_elements(workspace_unique_id=workspace_unique_id, \n subset_unique_id=subset_unique_id, \n request=request.get('quality_elements', {}))\n \n # Quality elements \n subset_dict['supporting_elements'] = self.list_supporting_elements(workspace_unique_id=workspace_unique_id, \n subset_unique_id=subset_unique_id, \n request=request.get('supporting_elements', {}))\n\n\n \n\n return subset_dict","def get_slice(self):\n return self.locs[tuple(self.indices), :]","def getSourceSubset(self, selection=None):\n if not selection or selection.lower() == \"all\":\n return self.sources\n # sort by brightness\n from past.builtins import cmp\n from functools import cmp_to_key\n srclist0 = sorted(self.sources, key=cmp_to_key(lambda a, b: cmp(b.brightness(), a.brightness())))\n all = set([src.name for src in srclist0])\n srcs = set()\n for ispec, spec in enumerate(re.split(\"\\s+|,\", selection)):\n spec = spec.strip()\n if spec:\n # if first spec is a negation, then implictly select all sources first\n if not ispec and spec[0] in \"!-\":\n srcs = all\n if spec.lower() == \"all\":\n srcs = all\n elif self._re_bynumber.match(spec):\n negate, start, end = self._re_bynumber.match(spec).groups()\n sl = slice(int(start) if start else None, int(end) if end else None)\n if negate:\n srcs.difference_update([src.name for src in srclist0[sl]])\n else:\n srcs.update([src.name for src in srclist0[sl]])\n elif spec.startswith(\"-=\") or spec.startswith(\"!=\"):\n srcs.difference_update([src.name for src in srclist0 if getattr(src, spec[2:], None)])\n elif spec.startswith(\"=\"):\n srcs.update([src.name for src in srclist0 if getattr(src, spec[1:], None)])\n elif spec.startswith(\"-\") or spec.startswith(\"!\"):\n srcs.discard(spec[1:])\n else:\n srcs.add(spec)\n # make list\n return [src for src in srclist0 if src.name in srcs]","def create_valid_subset(model_data, name, config):\n\n # Start with a mask that is True where the tech exists at a node (across all timesteps and for a each carrier and cost, where appropriate)\n imask = _imask_foreach(model_data, config.foreach)\n if imask is False: # i.e. not all of 'foreach' are in model_data\n return None\n # Add \"where\" info as imasks\n where_array = config.get_key(\"where\", default=[])\n if where_array:\n imask = _imask_where(model_data, name, where_array, imask, \"and_\")\n\n # Add imask based on subsets\n imask = _subset_imask(name, config, imask)\n\n # Only build and return imask if there are some non-zero elements\n if isinstance(imask, xr.DataArray) and imask.sum() != 0:\n # Squeeze out any unwanted dimensions\n if len(imask.dims) > len(config.foreach):\n imask = imask.sum([i for i in imask.dims if i not in config.foreach]) > 0\n # We have a problem if we have too few dimensions at this point...\n if len(imask.dims) < len(config.foreach):\n raise ValueError(f\"Missing dimension(s) in imask for set {name}\")\n\n valid_subset = _get_valid_subset(\n reorganise_xarray_dimensions(imask).astype(bool)\n )\n\n return valid_subset\n\n else:\n return None","def get_subsets(self, project):\n serializer = SubsetSerializer(project.subsets.all(), many=True)\n return serializer.data","def _get_portion(self, df, subset=1.0):\n amount = int(df.shape[0] * subset)\n random_indexes = np.random.choice(\n np.arange(df.shape[0]), size=amount, replace=False\n )\n return df.iloc[random_indexes].reset_index(drop=True)","def subset(self, variables=None, from_set=None, inplace=False):\n if not (variables or from_set) or (variables and from_set):\n err = \"Must pass either 'variables' or 'from_set'!\"\n raise ValueError(err)\n subset_ds = self.clone() if not inplace else self\n sets = subset_ds._meta['sets']\n if variables:\n from_set = 'subset'\n subset_ds.create_set(setname='subset', included=variables)\n else:\n if not from_set in sets:\n err = \"'{}' not found in meta 'sets' collection!\"\n raise KeyError(err.format(from_set))\n variables = [v.split('@')[-1] for v in sets[from_set]['items']]\n all_vars = subset_ds.columns() + subset_ds.masks()\n for var in all_vars:\n if not var in variables:\n if not self._is_array_item(var): subset_ds.drop(var)\n sets['data file']['items'] = sets[from_set]['items']\n del subset_ds._meta['sets'][from_set]\n\n if not inplace:\n return subset_ds\n else:\n return None","def __getslice__(self, i, j):\n return self.dtrs[i:j]","def get_slice(self, start: Optional[Index] = None, end: Optional[Index] = None):\n index = self._slice_index(slice(start, end))\n return self.get_table(index, self._columns)","def get_slice(dimensions, x=None, y=None):\n All = slice(None)\n\n if not dimensions:\n return All # so that it does not break processing \"mapping\"\n\n index_list = [All] * len(dimensions)\n\n if x != None:\n try:\n index_list[dimensions.index('x')] = x\n except:\n pass\n\n if y != None:\n try:\n index_list[dimensions.index('y')] = y\n except:\n pass\n\n return index_list","def get_subset(\n self,\n aggregation_level=None,\n country=None,\n fips: Optional[str] = None,\n state: Optional[str] = None,\n states: Optional[List[str]] = None,\n on: Optional[str] = None,\n after: Optional[str] = None,\n before: Optional[str] = None,\n columns: Sequence[str] = tuple(),\n ) -> \"TimeseriesDataset\":\n rows_key = dataset_utils.make_rows_key(\n self.data,\n aggregation_level=aggregation_level,\n country=country,\n fips=fips,\n state=state,\n states=states,\n on=on,\n after=after,\n before=before,\n )\n columns_key = list(columns) if columns else slice(None, None, None)\n return self.__class__(self.data.loc[rows_key, columns_key].reset_index(drop=True))","def request_subset_by_siteid(prod, band, network, siteid, start_date, end_date, \n qcfiltered = False):\n \n modis_start = modis_to_from_pydatetime(start_date)\n modis_end = modis_to_from_pydatetime(end_date)\n subset_str = '/subsetFiltered?' if qcfiltered else '/subset?'\n url_str = (''.join([api_base_url, prod, '/', network, '/', siteid, \n subset_str, band, '&startDate=', modis_start,\n '&endDate=', modis_end]))\n header = {'Accept': 'application/json'}\n response = requests.get(url_str, headers = header)\n subset = (json.loads(response.text))\n return _process_data([subset], band)","def _preprocess_fit_subset(fit_subset):\r\n\r\n if fit_subset is None:\r\n fit_subset_described = None\r\n elif isinstance(fit_subset, (list, np.ndarray)):\r\n fit_subset_described = fit_subset\r\n elif fit_subset == \"rewarded\":\r\n fit_subset_described = []\r\n elif fit_subset == \"unrewarded\":\r\n fit_subset_described = []\r\n elif fit_subset == \"all\":\r\n fit_subset_described = None\r\n elif isinstance(fit_subset, float) and np.isnan(fit_subset):\r\n fit_subset_described = []\r\n else:\r\n raise FitSubsetError('{} is not a known fit_subset'.format(fit_subset))\r\n\r\n return fit_subset_described","def get_slice(self, n):\n if n == 0:\n return slice(self._lo_atom, self._lo_atom + self._n_atoms)\n raise IndexError(f\"{n} is invalid for a 1 dimension Slice \")","def select(self, *dims):\n return select(self, *dims)","def request_subset_edit(self, request):\n user_id = request['user_id']\n workspace_uuid = request['workspace']['uuid']\n request_list = None\n if 'subsets' in request.keys():\n request_list = request['subsets']\n response = self.list_subsets(workspace_unique_id=workspace_uuid, user_id=user_id, request=request_list)\n \n return response","def subset_gen(itemSet):\n subsets = []\n for i in range(1, len(itemSet)):\n c = combinations(itemSet, r=i)\n for cc in c:\n subsets.append(set(cc))\n return subsets","def test_subset_by_band(self):\n\n this_satellite_dict = satellite_io.subset_by_band(\n satellite_dict=copy.deepcopy(SATELLITE_DICT_ALL_EXAMPLES),\n band_numbers=DESIRED_BAND_NUMBERS\n )\n\n self.assertTrue(compare_satellite_dicts(\n this_satellite_dict, SATELLITE_DICT_SUBSET_BY_BAND\n ))","def select(self):\n\t\tbest_num_components = self.n_constant\n\t\treturn self.base_model(best_num_components)","def __getslice__(self, i, j):\n return self.__getitem__(slice(i,j))","def __getslice__( self, *args):\n return array.array.__getslice__(self, *args).tostring()","def __getitem__(self, keep):\n ndim = len(self.dataset.shape)\n # Ensure that keep is a tuple (then turn it into a list to simplify further processing)\n keep = list(keep) if isinstance(keep, tuple) else [keep]\n # The original keep tuple will be passed to data transform chain\n original_keep = tuple(keep)\n # Ensure that keep is same length as data dimension (truncate or pad with blanket slices as necessary)\n keep = keep[:ndim] + [slice(None)] * (ndim - len(keep))\n # Map current selection to original data indices based on any existing initial selection, per data dimension\n keep = [(dkeep if dlookup is None else dlookup[dkeep]) for dkeep, dlookup in zip(keep, self._lookup)]\n # Iterate over dimensions of dataset, storing information on selection on each dimension:\n # `selection` is a list with one element per dimension; each element is a list of contiguous segments along\n # the dimension, and each segment is represented by a tuple of 3 elements:\n # (dataset selection, post-selection, output array selection)\n # Similarly, `segment_sizes` is a list of lists of segment lengths (empty lists for scalar-selected dimensions)\n selection, segment_sizes = [], []\n for dim_keep, dim_len in zip(keep, self.dataset.shape):\n if np.isscalar(dim_keep):\n # If selection is a scalar, pass directly to dataset selector and remove dimension from output\n selection.append([(dim_keep, None, None)])\n segment_sizes.append([])\n elif isinstance(dim_keep, slice):\n # If selection is a slice, pass directly to dataset selector without post-selection\n start, stop, stride = dim_keep.indices(dim_len)\n segm_size = len(range(start, stop, stride))\n selection.append([(slice(start, stop, stride), slice(None), slice(0, segm_size, 1))])\n segment_sizes.append([segm_size])\n elif len(dim_keep) == 0:\n # If selection is empty, pass to post-selector, as HDF5 datasets do not support zero-length selection\n selection.append([(slice(0, 1, 1), slice(0, 0, 1), slice(0, 0, 1))])\n segment_sizes.append([0])\n else:\n # Anything else is advanced indexing via bool or integer sequences\n dim_keep = np.atleast_1d(dim_keep)\n # Turn boolean mask into integer indices (True means keep that index)\n if dim_keep.dtype == bool and len(dim_keep) == dim_len:\n dim_keep = np.nonzero(dim_keep)[0]\n elif not np.all(dim_keep == np.unique(dim_keep)):\n raise TypeError('LazyIndexer cannot handle duplicate or unsorted advanced integer indices')\n # Split indices into multiple contiguous segments (specified by first and one-past-last data indices)\n jumps = np.nonzero(np.diff(dim_keep) > 1)[0]\n first = [dim_keep[0]] + dim_keep[jumps + 1].tolist()\n last = dim_keep[jumps].tolist() + [dim_keep[-1]]\n segments = np.c_[first, np.array(last) + 1]\n if len(dim_keep) > 0.2 * dim_len and len(segments) > 1:\n # If more than 20% of data are selected in 2 or more separate segments (the Ratcliffian benchmark),\n # select data at dataset level with a single slice spanning segments and then postselect the ndarray\n selection.append([(slice(segments[0, 0], segments[-1, 1], 1),\n dim_keep - dim_keep[0], slice(0, len(dim_keep), 1))])\n segment_sizes.append([len(dim_keep)])\n else:\n # Turn each segment into a separate slice at dataset level without post-selection,\n # and construct contiguous output slices of the same segment sizes\n segm_sizes = [end - start for start, end in segments]\n segm_starts = np.cumsum([0] + segm_sizes)\n selection.append([(slice(start, end, 1), slice(None), slice(segm_starts[n], segm_starts[n + 1], 1))\n for n, (start, end) in enumerate(segments)])\n segment_sizes.append(segm_sizes)\n # Short-circuit the selection if all dimensions are selected with scalars (resulting in a scalar output)\n if segment_sizes == [[]] * ndim:\n out_data = self.dataset[tuple([select[0][0] for select in selection])]\n else:\n # Use dense N-dimensional meshgrid to slice data set into chunks, based on segments along each dimension\n chunk_indices = np.mgrid[[slice(0, len(select), 1) for select in selection]]\n # Pre-allocate output ndarray to have the correct shape and dtype (will be at least 1-dimensional)\n out_data = np.empty([np.sum(segments) for segments in segment_sizes if segments], dtype=self.dataset.dtype)\n # Iterate over chunks, extracting them from dataset and inserting them into the right spot in output array\n for chunk_index in chunk_indices.reshape(ndim, -1).T:\n # Extract chunk from dataset (don't use any advanced indexing here, only scalars and slices)\n dataset_select = tuple([select[segment][0] for select, segment in zip(selection, chunk_index)])\n chunk = self.dataset[dataset_select]\n # Perform post-selection on chunk (can be fancier / advanced indexing because chunk is now an ndarray)\n post_select = [select[segment][1] for select, segment in zip(selection, chunk_index)]\n # If any dimensions were dropped due to scalar indexing, drop them from post_select/out_select tuples\n post_select = tuple([select for select in post_select if select is not None])\n # Do post-selection one dimension at a time, as ndarray does not allow simultaneous advanced indexing\n # on more than one dimension. This caters for the scenario where more than one dimension satisfies\n # the Ratcliffian benchmark (the only way to get advanced post-selection).\n for dim in range(len(chunk.shape)):\n # Only do post-selection on this dimension if non-trivial (otherwise an unnecessary copy happens)\n if not (isinstance(post_select[dim], slice) and post_select[dim] == slice(None)):\n # Prepend the appropriate number of colons to the selection to place it at correct dimension\n chunk = chunk[[slice(None)] * dim + [post_select[dim]]]\n # Determine appropriate output selection and insert chunk into output array\n out_select = [select[segment][2] for select, segment in zip(selection, chunk_index)]\n out_select = tuple([select for select in out_select if select is not None])\n out_data[out_select] = chunk\n # Apply transform chain to output data, if any\n return reduce(lambda data, transform: transform(data, original_keep), self.transforms, out_data)","def find_proper_subsets(powerset, cardinality_difference = 1, debug = False):\n subset_idx = [] # Which will be set A of the powerset\n superset_idx = [] # Which will be set B of the powerset\n\n for A, a_idx in zip(powerset, list(range(0, len(powerset)))):\n # A_is_proper_subset_of_B = True\n for B, b_idx in zip(powerset[a_idx:], list(range(a_idx, len(powerset)))):\n if len(A) is not len(B)-cardinality_difference:\n continue\n else: # Check every element\n for a in A:\n A_is_proper_subset_of_B = True\n found_a_in_b = False\n for b in B:\n if a is b:\n found_a_in_b = True\n break\n if found_a_in_b is False:\n A_is_proper_subset_of_B = False\n if A_is_proper_subset_of_B:\n if debug:\n print(\"A:\", A, \" is proper subset of B:\", B)\n subset_idx.append(a_idx)\n superset_idx.append(b_idx)\n # return the indecees for the corresponding sets\n #print(\"subset_idx: \", subset_idx)\n #print(\"superset_idx: \", superset_idx)\n return subset_idx, superset_idx","def _select_fields(self):\r\n return []","def get_slice(self, limit, offset):\r\n if limit == 0:\r\n return self.objects[offset:]\r\n\r\n return self.objects[offset:offset + limit]","def __getslice__(self,i,j):\n return self.x[i:j]","def test_subset_reconstruction_iterable(self, wires):\n circuit = hadamard_circuit(wires)\n bits, recipes = circuit()\n shadow = ClassicalShadow(bits, recipes)\n\n # choose 1000 random indices\n snapshots = np.random.choice(np.arange(10000, dtype=np.int64), size=1000, replace=False)\n state = shadow.global_snapshots(snapshots=snapshots)\n assert state.shape == (len(snapshots), 2**wires, 2**wires)\n\n # check the results against obtaining the full global snapshots\n expected = shadow.global_snapshots()\n for i, t in enumerate(snapshots):\n assert np.allclose(expected[t], state[i])","def __getslice__(self, i, j):\n return self.__getitem__(slice(i, j))","def spatial_subset(dataset: xr.Dataset,\n bbox: Tuple[float, float, float, float]) -> xr.Dataset:\n x1, y1, x2, y2 = bbox\n gm = GridMapping.from_dataset(dataset)\n x_name, y_name = gm.xy_dim_names\n return dataset.sel({\n x_name: slice(x1, x2),\n y_name: slice(y1, y2) if gm.is_j_axis_up else slice(y2, y1)\n })","def subset(dataset, article_indices):\n indices = []\n for a_id in article_indices:\n indices += dataset.get_article_indices(a_id)\n return Subset(dataset, indices)","def get_subset(self, tile, band=0):\r\n # access window bounds\r\n bounds = rasterio.windows.bounds(tile, self.dataset.transform)\r\n return (\r\n self.__arr[(band,) + tile.toslices()],\r\n bounds,\r\n ) # Shape of array is announced with (bands, height, width)\r","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 select_partial_data(self, anneal, my_data):\n partial = anneal['partial']\n\n if partial == 0 or partial == 1: # partial == full data\n return my_data\n\n my_N, D = my_data['y'].shape \n my_pN = int(np.ceil(my_N * partial))\n\n if my_N == my_pN: # partial == full data\n return my_data\n\n # Choose subset...\n sel = np.random.permutation(my_N)[:my_pN]\n sel.sort()\n\n # Construct partial my_pdata...\n my_pdata = {}\n for key, val in my_data.items():\n my_pdata[key] = val[sel]\n\n return my_pdata","def get_subtechniques_of():\n global subtechniques_of\n\n if not subtechniques_of:\n subtechniques_of = rsh.subtechniques_of(get_srcs())\n \n return subtechniques_of","def properSubset(stack):\n assertArity(stack, 2)\n rhs, lhs = stack.pop(), stack.pop()\n assertType(lhs, Set)\n assertType(rhs, Set)\n return lhs < rhs","def subset(self, parameter_str, bounds):\n # Copy range and prevent change of original\n res_cov_range = copy.deepcopy(self)\n\n parameters = self.file2res.parameters\n cov = res_cov_range.covariance\n mpar = res_cov_range.mpar\n # Create mask\n mask1 = parameters[parameter_str] >= bounds[0]\n mask2 = parameters[parameter_str] <= bounds[1]\n mask = mask1 & mask2\n res_cov_range.parameters = parameters[mask]\n indices = res_cov_range.parameters.index.values\n # Build subset of covariance\n sub_cov_dim = len(indices)*mpar\n cov_subset_vals = []\n for index1 in indices:\n for i in range(mpar):\n for index2 in indices:\n for j in range(mpar):\n if index2*mpar+j >= index1*mpar+i:\n cov_subset_vals.append(cov[index1*mpar+i,\n index2*mpar+j])\n\n cov_subset = np.zeros([sub_cov_dim, sub_cov_dim])\n tri_indices = np.triu_indices(sub_cov_dim)\n cov_subset[tri_indices] = cov_subset_vals\n\n res_cov_range.file2res.parameters = parameters[mask]\n res_cov_range.covariance = cov_subset\n return res_cov_range","def _get_family_slice(self, fam):\n try:\n return self._family_slice[fam]\n except KeyError:\n return slice(0, 0)","def __get_slice(islice, isize):\n if islice[0] is None:\n if islice[1] is None:\n return slice(isize)\n else:\n return slice(islice[1])\n else:\n if islice[1] is None:\n return slice(islice[0], isize)\n else:\n return slice(islice[0], islice[1])","def subset(stack):\n assertArity(stack, 2)\n rhs, lhs = stack.pop(), stack.pop()\n assertType(lhs, Set)\n assertType(rhs, Set)\n return lhs <= rhs","def subset(searchString):\n print(f'📇 Download subset: {self.__repr__()}{\" \":60s}')\n \n outFile = self.get_local(searchString=searchString)\n \n if not overwrite and outFile.exists():\n if verbose: print(f'🌉 Already have local copy --> {outFile}')\n self.local_grib_subset = outFile\n else:\n # Download subsets of the file by byte range with cURL.\n for i, (grbmsg, row) in enumerate(self.idx_df.iterrows()):\n print(f\"{i+1:>4g}: GRIB_message={grbmsg:<3g} \\033[34m{row.variable}:{row.level}:{row.forecast_time}\\033[m\")\n if i == 0:\n # If we are working on the first item, overwrite the existing file...\n curl = f'curl -s --range {row.range} {self.grib} > {outFile}'\n else:\n # ...all other messages are appended to the subset file.\n curl = f'curl -s --range {row.range} {self.grib} >> {outFile}'\n os.system(curl)\n\n self.local_grib_subset = outFile","def get_design_parameters(self):\n return self.__get_one_type_params(DesignParameter)","def get_slice(self, node_id, nodes_in_slice, is_origin=False, is_reverse=False):\n if is_reverse:\n return self.get_reverse_slice(node_id, nodes_in_slice)\n return self.get_level_element_slice(node_id, nodes_in_slice, is_origin=is_origin)","def slice(self, field):\n return [getattr(r, field) for r in self.__elements__]","def intSubset(self):\n ret = libxml2mod.xmlGetIntSubset(self._o)\n if ret is None:raise treeError('xmlGetIntSubset() failed')\n __tmp = xmlDtd(_obj=ret)\n return __tmp","def get_dataset_slice(\n global_params, full_dataset, start_idx, size, dataset=None):\n if size <= 0 or start_idx + size > full_dataset.num_points:\n raise IndexError\n if dataset is None:\n dataset = Dataset()\n dataset.num_points = size\n dataset.init_aux_structures(global_params)\n full_points_ref = full_dataset.get_ref('points')\n dataset_points_ref = dataset.get_ref('points')\n for i in range(size):\n for j in range(global_params.dims):\n dataset_points_ref[i][j] = full_points_ref[start_idx + i][j]\n return dataset"],"string":"[\n \"def get_designs(self):\",\n \"def subset(\\n self, \\n include: Union[Sequence[Any], Any] = None, \\n exclude: Union[Sequence[Any], Any] = None) -> Bunch:\\n pass\",\n \"def default_subset(self):\\n\\t\\treturn [slice(0,dim.length) for dim in self.variable.dimensions]\",\n \"def get_subset(self, name):\\n assert name in ['train', 'valid', 'test'], f'Invalid dataset name! {name} has been provided but must be one of [train, valid, test]'\\n return self.subsets[name]\",\n \"def subset_(self):\\n return self.X.ix[:, self.important_features_]\",\n \"def internalSubset(self, name, externalID, systemID):\\n pass\",\n \"def get_subset_list(self):\\n\\n return self.subset_list\",\n \"def test_general_subset_dset():\\n pass\",\n \"def _make_subset(cls, name, data, **kwargs):\\r\\n return cls(name, data, **kwargs)\",\n \"def test_general_subset_all():\\n pass\",\n \"def _subset(self, idxs):\\n vertices = [self.vertices[i] for i in idxs]\\n if hasattr(self, \\\"data\\\"):\\n data = Table(data=[self.data._data[i] for i in idxs], fields=self.data.fields)\\n return type(self)(vertices, properties=self.properties, data=data, crs=self.crs)\\n else:\\n return type(self)(vertices, properties=self.properties, crs=self.crs)\",\n \"def _getSubset(self, label):\\n\\n if self._flags is None:\\n self._flags = {}\\n self._subsets = {}\\n elif flags.TIMESTAMP != self._flagsts:\\n self._resetFlags()\\n self._flagsts = flags.TIMESTAMP\\n\\n try:\\n return self._subsets[label]\\n except KeyError:\\n flgs = self._getFlags(label)\\n try:\\n return self._subsets[label]\\n except KeyError:\\n indices = flgs.nonzero()[0]\\n self._setSubset(label, indices)\\n return indices.copy()\",\n \"def subsetter(self, font, subset):\\n options = Options()\\n options.layout_features = \\\"*\\\" # keep all GSUB/GPOS features\\n # options.no_layout_closure = True # TESTING\\n options.glyph_names = False # keep post glyph names\\n options.legacy_cmap = True # keep non-Unicode cmaps\\n options.name_legacy = True # keep non-Unicode names\\n options.name_IDs = [\\\"*\\\"] # keep all nameIDs\\n options.name_languages = [\\\"*\\\"] # keep all name languages\\n options.notdef_outline = False\\n options.ignore_missing_glyphs = True\\n options.prune_unicode_ranges = True\\n options.recommended_glyphs = True\\n subsetter = Subsetter(options=options)\\n subsetter.populate(glyphs=subset)\\n subsetter.subset(font)\\n\\n return font\",\n \"def pulledsubset(self):\\n # compute target subset\\n if self.heads is None:\\n # We pulled every thing possible\\n # sync on everything common\\n c = set(self.common)\\n ret = list(self.common)\\n for n in self.rheads:\\n if n not in c:\\n ret.append(n)\\n return ret\\n else:\\n # We pulled a specific subset\\n # sync on this subset\\n return self.heads\",\n \"def get_subset(self, start=None, end=None):\\n \\n if start is None and end is None:\\n return self.img_lst\\n elif start is None:\\n return self.img_lst[:end]\\n elif end is None:\\n return self.img_lst[start:]\\n else:\\n return self.img_lst[start:end]\",\n \"def is_subset(self, other):\",\n \"def Get(self,k:int): \\n ### get partitions depending on the partition schemes C that depends on k!\\n return subsets_k(list(range(self._n)),k)\",\n \"def _subset(self, idxs):\\n vertices = [self.vertices[i] for i in idxs]\\n subset = Line(vertices, properties=self.properties, crs=self.crs)\\n return subset\",\n \"def design(self):\\n return self[self.design_columns]\",\n \"def design(self):\\n return self[self.design_columns]\",\n \"def get_uniform_subset(self, samples_per_label):\\n raise NotImplementedError\",\n \"def externalSubset(self, name, externalID, systemID):\\n pass\",\n \"def test_general_subset_level():\\n pass\",\n \"def __getslice__(self, start, stop):\\n return self.__getitem__(slice(start, stop, None))\",\n \"def get_subset_rt(self, rt):\\n regions = self.boxes_rt.at(rt)\\n it = BoxHolder()\\n for r in regions:\\n box = r.data\\n it.add_box(box)\\n return it\",\n \"def test_general_subset_space():\\n pass\",\n \"def build_subsets(self):\\n self.all = nrn.SectionList()\\n self.all.wholetree(sec=self.soma)\",\n \"def get_data_subset(selection, network_type='drive', infrastructure='way[\\\"highway\\\"]'):\\n paths = []\\n nodes = []\\n if infrastructure == 'node[\\\"highway\\\"]':\\n nodes = [n for n in selection[0]['elements'] if n['type'] == 'node' and 'tags' in n and 'highway' in n['tags']]\\n else:\\n paths = [p for p in selection[0]['elements'] if p['type'] == 'way'\\n and check_infrastructure(infrastructure, p)\\n and check_network(network_type, p)\\n ]\\n\\n if not nodes:\\n node_ids = []\\n for p in paths:\\n if 'nodes' not in p:\\n continue\\n node_ids.extend(p['nodes'])\\n\\n nodes = [n for n in selection[0]['elements'] if n['id'] in node_ids]\\n\\n return [{'version': selection[0]['version'],\\n 'osm3s': selection[0]['osm3s'],\\n 'generator': selection[0]['generator'],\\n 'bounds': selection[0]['bounds'],\\n 'elements': paths + nodes\\n }\\n ]\",\n \"def getslice(self, *args, **kwargs):\\n return _image.image_getslice(self, *args, **kwargs)\",\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 all(self, name, codes):\\n if self.is_array(name):\\n logics = []\\n for s in self.sources(name):\\n logics.append({s: has_all(codes)})\\n slicer = self.take(intersection(logics))\\n else:\\n slicer = self.take({name: has_all(codes)})\\n return slicer\",\n \"def api_subset_lookup(cur):\\n if 'api_subset' not in _tables:\\n rclass = rclass_id_lookup(cur)\\n _tables['api_subset'] = dict((k, rclass[v]) for k, v in API_SUBSETS.items())\\n return _tables['api_subset']\",\n \"def sub_set(self, idcs):\\n return SubSet(dset=self, idcs=idcs)\",\n \"def getSlice(properties=None, **kw):\",\n \"def select_fits_subset(self, pre_processing=None, binning=None,\\n exposure=(None, 'max'), reduction=None,\\n observatory=None, jd=(None, 'exact')):\\n self.data_subset = self.all_data.copy()\\n\\n # Select on pre-processing if provided.\\n if pre_processing:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['PreProcessing'] == pre_processing]\\n\\n # Select on binning if provided.\\n if binning:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Binning'] == binning]\\n\\n # Select on exposure if provided.\\n if exposure[0]:\\n if exposure[1] == 'exact':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Exposure'] == exposure[0]]\\n elif exposure[1] == 'min':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Exposure'] > exposure[0]]\\n elif exposure[1] == 'max':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Exposure'] < exposure[0]]\\n elif exposure[1] == 'between':\\n self.data_subset = self.data_subset.loc[\\n (self.data_subset['Exposure'] > exposure[0][0]) &\\n (self.data_subset['Exposure'] < exposure[0][1])]\\n\\n # Select on reduction if provided.\\n if reduction:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Reduction'] == reduction]\\n\\n # Select on observatory if provided.\\n if observatory:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Observatory'] == observatory]\\n\\n # Select on jd if provided.\\n if jd[0]:\\n if jd[1] == 'exact':\\n if isinstance(jd[0], list):\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['JD'].isin(jd[0])]\\n else:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['JD'] == jd[0]]\\n elif jd[1] == 'except':\\n if isinstance(jd[0], list):\\n self.data_subset = self.data_subset.drop(\\n self.data_subset[self.data_subset[\\n 'JD'].isin(jd[0])].index)\\n else:\\n self.data_subset = self.data_subset.drop(\\n self.data_subset[self.data_subset['JD']\\n == jd[0]].index)\\n elif jd[1] == 'after':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['JD'] > jd[0]]\\n elif jd[1] == 'before':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['JD'] < jd[0]]\\n elif jd[1] == 'between':\\n self.data_subset = self.data_subset.loc[\\n (self.data_subset['JD'] > jd[0][0]) &\\n (self.data_subset['JD'] < jd[0][1])]\\n\\n # Sort by JD and reset index.\\n self.data_subset = self.data_subset.sort_values(\\n by=['JD'], ascending=True).reset_index(drop=True)\\n\\n # Check spectra found:\\n if len(self.data_subset) == 0:\\n raise FileExistsError(\\n 'No spectra found for that location or subset.')\\n\\n print('Selecting {} spectra from fits dataset.'.format(\\n len(self.data_subset)))\",\n \"def extract_subset(self, subset):\\n \\n # note subsets have an unusual encoding\\n query = \\\"\\\"\\\"\\n prefix oboInOwl: <http://www.geneontology.org/formats/oboInOwl#>\\n SELECT ?c WHERE {{\\n GRAPH <{g}> {{\\n ?c oboInOwl:inSubset ?s\\n FILTER regex(?s,'#{s}$','i')\\n }}\\n }}\\n \\\"\\\"\\\".format(s=subset, g=self.graph_name)\\n bindings = run_sparql(query)\\n return [r['c']['value'] for r in bindings]\",\n \"def feature_subset(self,node,db,labels,ids):\\n return None\",\n \"def getSets():\",\n \"def subsets(self):\\n \\n # note subsets have an unusual encoding\\n query = \\\"\\\"\\\"\\n prefix oboInOwl: <http://www.geneontology.org/formats/oboInOwl#>\\n SELECT DISTINCT ?s WHERE {{\\n GRAPH <{g}> {{\\n ?c oboInOwl:inSubset ?s \\n }}\\n }}\\n \\\"\\\"\\\".format(g=self.graph_name)\\n bindings = run_sparql(query)\\n return [r['s']['value'] for r in bindings]\",\n \"def subset(self,n):\\n\\n if n>=len(self):\\n\\n warning.warn(f\\\"\\\"\\\" SweepParam.subset : {n} larger than SweepParam length ({len(self)})\\\"\\\"\\\")\\n\\n return self\\n\\n from numpy import ceil\\n\\n if len(self)%2==1:\\n\\n spacing=int(floor((len(self)+1)/n))\\n\\n else:\\n\\n spacing=int(floor(len(self)/n))\\n\\n new_dict={}\\n\\n for name in self.names:\\n\\n old_values=self._dict[name]\\n\\n new_values=[old_values[x] for x in range(0,len(self)-1,spacing)]\\n\\n if not len(new_values)==n:\\n\\n import pdb; pdb.set_trace()\\n raise ValueError(\\\"bug in subset creation, wrong length\\\")\\n\\n else:\\n\\n new_dict[name]=new_values\\n\\n return SweepParam(new_dict)\",\n \"def __iter__(self):\\r\\n if self._shuffle:\\r\\n perm = torch.randperm(self._subset_size)\\r\\n return iter(self._subset[perm].tolist())\\r\\n return iter(self._subset)\",\n \"def getSubsets(cityIndicesExcluding1, subsetSizeWithout1):\\r\\n\\r\\n # Getting subsets of specific size excluding start vertex, i.e.,city 1 and without the city 1\\r\\n subsets = []\\r\\n X = list( itertools.combinations(cityIndicesExcluding1, subsetSizeWithout1) )\\r\\n\\r\\n # Appending start vertex, i.e., city 1 to each subset\\r\\n for x in X:\\r\\n x = ( 1, ) + x\\r\\n subsets.append( x )\\r\\n\\r\\n return subsets\",\n \"def check_subset(P1,P2,k=-1):\",\n \"def test_get_software_set_expanded(self):\\n pass\",\n \"def ifc_subsets(me, ifc):\\n return me._ifc_subs.get(ifc, frozenset())\",\n \"def test_query_subset_response_AdventureWorks2014(self):\\n\\n with open(self.get_test_baseline(u'select_from_humanresources_department_adventureworks2014.txt'), u'r+b', buffering=0) as response_file:\\n request_stream = io.BytesIO()\\n rpc_client = json_rpc_client.JsonRpcClient(\\n request_stream, response_file)\\n rpc_client.start()\\n # Submit a dummy request.\\n parameters = {u'OwnerUri': u'connectionservicetest',\\n u'BatchIndex': 0,\\n u'ResultSetIndex': 0,\\n u'RowsStartIndex': 0,\\n u'RowCount': 16}\\n\\n request = queryservice.QuerySubsetRequest(\\n 3, rpc_client, parameters)\\n self.verify_subset_response(request=request)\\n rpc_client.shutdown()\",\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 test_general_subset_invalid_level():\\n pass\",\n \"def subsets(self):\\n return set(self.subset_map.values())\",\n \"def get_slice(self, sim):\\n # TODO: This function is definitely not general. We need to get a list\\n # of layers to exclude from the user. For now, just assume we want to\\n # exclude the top and bottom regions\\n # sorted_layers is an OrderedDict, and thus has the popitem method\\n sorted_layers = sim.conf.sorted_dict(sim.conf['Layers'])\\n first_layer = sorted_layers.popitem(last=False)\\n last_layer = sorted_layers.popitem()\\n # We can get the starting and ending planes from their heights\\n start_plane = int(round(first_layer[1]['params'][\\n 'thickness'] / sim.dz))\\n end_plane = int(round(last_layer[1]['params'][\\n 'thickness'] / sim.dz))\\n return start_plane, end_plane\",\n \"def set_subset(self):\\r\\n if self._random_subset:\\r\\n perm = torch.randperm(len(self._indices))\\r\\n self._subset = self._indices[perm][:self._subset_size]\\r\\n else:\\r\\n self._subset = torch.Tensor(self._indices[:self._subset_size])\",\n \"def get_subset(df, constraints):\\n for constraint in constraints:\\n subset = df.loc[df[constraint[0]].isin(constraint[1])]\\n df = subset\\n return subset\",\n \"def select(self):\\n return self.recipeset\",\n \"def __getitem__(self,key):\\n if type(key) is types.SliceType: #Or can use 'try:' for speed\\n return FeatureSet(list.__getitem__(self, key))\\n else:\\n return list.__getitem__(self,key)\",\n \"def request_subset_list(self, request):\\n user_id = request['user_id']\\n workspace_uuid = request['workspace_uuid'] \\n \\n # Initiate structure \\n response = {'workspace': {}, \\n 'subsets': []}\\n \\n # Add workspace info\\n response['workspace'] = self.dict_workspace(unique_id=workspace_uuid, user_id=user_id)\\n \\n subset_list = self.list_subsets(workspace_unique_id=workspace_uuid, user_id=user_id)\\n \\n # Add subset info \\n response['subsets'] = subset_list\\n \\n return response\",\n \"def extract_subset_idx(self, start_idx, end_idx):\\r\\n templist = ChannelList()\\r\\n # Burris and Scintrex have different fields. This only returns non-empty fields.\\r\\n for field, value in self:\\r\\n temp = value[start_idx : end_idx + 1]\\r\\n setattr(templist, field, temp)\\r\\n return templist\",\n \"def dict_subset(self, workspace_unique_id=None, subset_unique_id=None, request=None):\\n workspace_object = self._get_workspace_object(unique_id=workspace_unique_id)\\n \\n subset_dict = {'alias': None,\\n 'uuid': None,\\n 'status': None,\\n 'active': None,\\n 'time': {}, \\n 'periods': [], # Should be removed\\n 'water_bodies': [], \\n 'water_districts': [], \\n 'supporting_elements': [], \\n 'quality_elements': []}\\n \\n # Check request \\n if request:\\n if request['active']:\\n workspace_object.uuid_mapping.set_active(subset_unique_id)\\n else:\\n workspace_object.uuid_mapping.set_inactive(subset_unique_id)\\n\\n else:\\n subset_dict['alias'] = workspace_object.uuid_mapping.get_alias(subset_unique_id, status=self.all_status) \\n subset_dict['uuid'] = subset_unique_id\\n subset_dict['status'] = workspace_object.uuid_mapping.get_status(unique_id=subset_unique_id) \\n subset_dict['active'] = workspace_object.uuid_mapping.is_active(unique_id=subset_unique_id)\\n \\n subset_dict = {'time': {}, \\n 'periods': [], # Should be removed\\n 'water_bodies': [], \\n 'water_districts': [], \\n 'supporting_elements': [], \\n 'quality_elements': []}\\n \\n if request == None: \\n request = {}\\n \\n \\n # Time\\n subset_dict['time'] = self.dict_time(workspace_unique_id=workspace_unique_id, \\n subset_unique_id=subset_unique_id, \\n request=request.get('time', {}))\\n \\n # Deprecated list for periods\\n subset_dict['periods'] = self.list_periods(workspace_unique_id=workspace_unique_id, \\n subset_unique_id=subset_unique_id, \\n request=request.get('periods', {}))\\n \\n \\n # Areas (contains water_district, type_area and water_body in a tree structure) \\n subset_dict['areas'] = self.list_areas(workspace_unique_id=workspace_unique_id, \\n subset_unique_id=subset_unique_id, \\n request=request.get('areas', {}))\\n \\n # Quality elements \\n subset_dict['quality_elements'] = self.list_quality_elements(workspace_unique_id=workspace_unique_id, \\n subset_unique_id=subset_unique_id, \\n request=request.get('quality_elements', {}))\\n \\n # Quality elements \\n subset_dict['supporting_elements'] = self.list_supporting_elements(workspace_unique_id=workspace_unique_id, \\n subset_unique_id=subset_unique_id, \\n request=request.get('supporting_elements', {}))\\n\\n\\n \\n\\n return subset_dict\",\n \"def get_slice(self):\\n return self.locs[tuple(self.indices), :]\",\n \"def getSourceSubset(self, selection=None):\\n if not selection or selection.lower() == \\\"all\\\":\\n return self.sources\\n # sort by brightness\\n from past.builtins import cmp\\n from functools import cmp_to_key\\n srclist0 = sorted(self.sources, key=cmp_to_key(lambda a, b: cmp(b.brightness(), a.brightness())))\\n all = set([src.name for src in srclist0])\\n srcs = set()\\n for ispec, spec in enumerate(re.split(\\\"\\\\s+|,\\\", selection)):\\n spec = spec.strip()\\n if spec:\\n # if first spec is a negation, then implictly select all sources first\\n if not ispec and spec[0] in \\\"!-\\\":\\n srcs = all\\n if spec.lower() == \\\"all\\\":\\n srcs = all\\n elif self._re_bynumber.match(spec):\\n negate, start, end = self._re_bynumber.match(spec).groups()\\n sl = slice(int(start) if start else None, int(end) if end else None)\\n if negate:\\n srcs.difference_update([src.name for src in srclist0[sl]])\\n else:\\n srcs.update([src.name for src in srclist0[sl]])\\n elif spec.startswith(\\\"-=\\\") or spec.startswith(\\\"!=\\\"):\\n srcs.difference_update([src.name for src in srclist0 if getattr(src, spec[2:], None)])\\n elif spec.startswith(\\\"=\\\"):\\n srcs.update([src.name for src in srclist0 if getattr(src, spec[1:], None)])\\n elif spec.startswith(\\\"-\\\") or spec.startswith(\\\"!\\\"):\\n srcs.discard(spec[1:])\\n else:\\n srcs.add(spec)\\n # make list\\n return [src for src in srclist0 if src.name in srcs]\",\n \"def create_valid_subset(model_data, name, config):\\n\\n # Start with a mask that is True where the tech exists at a node (across all timesteps and for a each carrier and cost, where appropriate)\\n imask = _imask_foreach(model_data, config.foreach)\\n if imask is False: # i.e. not all of 'foreach' are in model_data\\n return None\\n # Add \\\"where\\\" info as imasks\\n where_array = config.get_key(\\\"where\\\", default=[])\\n if where_array:\\n imask = _imask_where(model_data, name, where_array, imask, \\\"and_\\\")\\n\\n # Add imask based on subsets\\n imask = _subset_imask(name, config, imask)\\n\\n # Only build and return imask if there are some non-zero elements\\n if isinstance(imask, xr.DataArray) and imask.sum() != 0:\\n # Squeeze out any unwanted dimensions\\n if len(imask.dims) > len(config.foreach):\\n imask = imask.sum([i for i in imask.dims if i not in config.foreach]) > 0\\n # We have a problem if we have too few dimensions at this point...\\n if len(imask.dims) < len(config.foreach):\\n raise ValueError(f\\\"Missing dimension(s) in imask for set {name}\\\")\\n\\n valid_subset = _get_valid_subset(\\n reorganise_xarray_dimensions(imask).astype(bool)\\n )\\n\\n return valid_subset\\n\\n else:\\n return None\",\n \"def get_subsets(self, project):\\n serializer = SubsetSerializer(project.subsets.all(), many=True)\\n return serializer.data\",\n \"def _get_portion(self, df, subset=1.0):\\n amount = int(df.shape[0] * subset)\\n random_indexes = np.random.choice(\\n np.arange(df.shape[0]), size=amount, replace=False\\n )\\n return df.iloc[random_indexes].reset_index(drop=True)\",\n \"def subset(self, variables=None, from_set=None, inplace=False):\\n if not (variables or from_set) or (variables and from_set):\\n err = \\\"Must pass either 'variables' or 'from_set'!\\\"\\n raise ValueError(err)\\n subset_ds = self.clone() if not inplace else self\\n sets = subset_ds._meta['sets']\\n if variables:\\n from_set = 'subset'\\n subset_ds.create_set(setname='subset', included=variables)\\n else:\\n if not from_set in sets:\\n err = \\\"'{}' not found in meta 'sets' collection!\\\"\\n raise KeyError(err.format(from_set))\\n variables = [v.split('@')[-1] for v in sets[from_set]['items']]\\n all_vars = subset_ds.columns() + subset_ds.masks()\\n for var in all_vars:\\n if not var in variables:\\n if not self._is_array_item(var): subset_ds.drop(var)\\n sets['data file']['items'] = sets[from_set]['items']\\n del subset_ds._meta['sets'][from_set]\\n\\n if not inplace:\\n return subset_ds\\n else:\\n return None\",\n \"def __getslice__(self, i, j):\\n return self.dtrs[i:j]\",\n \"def get_slice(self, start: Optional[Index] = None, end: Optional[Index] = None):\\n index = self._slice_index(slice(start, end))\\n return self.get_table(index, self._columns)\",\n \"def get_slice(dimensions, x=None, y=None):\\n All = slice(None)\\n\\n if not dimensions:\\n return All # so that it does not break processing \\\"mapping\\\"\\n\\n index_list = [All] * len(dimensions)\\n\\n if x != None:\\n try:\\n index_list[dimensions.index('x')] = x\\n except:\\n pass\\n\\n if y != None:\\n try:\\n index_list[dimensions.index('y')] = y\\n except:\\n pass\\n\\n return index_list\",\n \"def get_subset(\\n self,\\n aggregation_level=None,\\n country=None,\\n fips: Optional[str] = None,\\n state: Optional[str] = None,\\n states: Optional[List[str]] = None,\\n on: Optional[str] = None,\\n after: Optional[str] = None,\\n before: Optional[str] = None,\\n columns: Sequence[str] = tuple(),\\n ) -> \\\"TimeseriesDataset\\\":\\n rows_key = dataset_utils.make_rows_key(\\n self.data,\\n aggregation_level=aggregation_level,\\n country=country,\\n fips=fips,\\n state=state,\\n states=states,\\n on=on,\\n after=after,\\n before=before,\\n )\\n columns_key = list(columns) if columns else slice(None, None, None)\\n return self.__class__(self.data.loc[rows_key, columns_key].reset_index(drop=True))\",\n \"def request_subset_by_siteid(prod, band, network, siteid, start_date, end_date, \\n qcfiltered = False):\\n \\n modis_start = modis_to_from_pydatetime(start_date)\\n modis_end = modis_to_from_pydatetime(end_date)\\n subset_str = '/subsetFiltered?' if qcfiltered else '/subset?'\\n url_str = (''.join([api_base_url, prod, '/', network, '/', siteid, \\n subset_str, band, '&startDate=', modis_start,\\n '&endDate=', modis_end]))\\n header = {'Accept': 'application/json'}\\n response = requests.get(url_str, headers = header)\\n subset = (json.loads(response.text))\\n return _process_data([subset], band)\",\n \"def _preprocess_fit_subset(fit_subset):\\r\\n\\r\\n if fit_subset is None:\\r\\n fit_subset_described = None\\r\\n elif isinstance(fit_subset, (list, np.ndarray)):\\r\\n fit_subset_described = fit_subset\\r\\n elif fit_subset == \\\"rewarded\\\":\\r\\n fit_subset_described = []\\r\\n elif fit_subset == \\\"unrewarded\\\":\\r\\n fit_subset_described = []\\r\\n elif fit_subset == \\\"all\\\":\\r\\n fit_subset_described = None\\r\\n elif isinstance(fit_subset, float) and np.isnan(fit_subset):\\r\\n fit_subset_described = []\\r\\n else:\\r\\n raise FitSubsetError('{} is not a known fit_subset'.format(fit_subset))\\r\\n\\r\\n return fit_subset_described\",\n \"def get_slice(self, n):\\n if n == 0:\\n return slice(self._lo_atom, self._lo_atom + self._n_atoms)\\n raise IndexError(f\\\"{n} is invalid for a 1 dimension Slice \\\")\",\n \"def select(self, *dims):\\n return select(self, *dims)\",\n \"def request_subset_edit(self, request):\\n user_id = request['user_id']\\n workspace_uuid = request['workspace']['uuid']\\n request_list = None\\n if 'subsets' in request.keys():\\n request_list = request['subsets']\\n response = self.list_subsets(workspace_unique_id=workspace_uuid, user_id=user_id, request=request_list)\\n \\n return response\",\n \"def subset_gen(itemSet):\\n subsets = []\\n for i in range(1, len(itemSet)):\\n c = combinations(itemSet, r=i)\\n for cc in c:\\n subsets.append(set(cc))\\n return subsets\",\n \"def test_subset_by_band(self):\\n\\n this_satellite_dict = satellite_io.subset_by_band(\\n satellite_dict=copy.deepcopy(SATELLITE_DICT_ALL_EXAMPLES),\\n band_numbers=DESIRED_BAND_NUMBERS\\n )\\n\\n self.assertTrue(compare_satellite_dicts(\\n this_satellite_dict, SATELLITE_DICT_SUBSET_BY_BAND\\n ))\",\n \"def select(self):\\n\\t\\tbest_num_components = self.n_constant\\n\\t\\treturn self.base_model(best_num_components)\",\n \"def __getslice__(self, i, j):\\n return self.__getitem__(slice(i,j))\",\n \"def __getslice__( self, *args):\\n return array.array.__getslice__(self, *args).tostring()\",\n \"def __getitem__(self, keep):\\n ndim = len(self.dataset.shape)\\n # Ensure that keep is a tuple (then turn it into a list to simplify further processing)\\n keep = list(keep) if isinstance(keep, tuple) else [keep]\\n # The original keep tuple will be passed to data transform chain\\n original_keep = tuple(keep)\\n # Ensure that keep is same length as data dimension (truncate or pad with blanket slices as necessary)\\n keep = keep[:ndim] + [slice(None)] * (ndim - len(keep))\\n # Map current selection to original data indices based on any existing initial selection, per data dimension\\n keep = [(dkeep if dlookup is None else dlookup[dkeep]) for dkeep, dlookup in zip(keep, self._lookup)]\\n # Iterate over dimensions of dataset, storing information on selection on each dimension:\\n # `selection` is a list with one element per dimension; each element is a list of contiguous segments along\\n # the dimension, and each segment is represented by a tuple of 3 elements:\\n # (dataset selection, post-selection, output array selection)\\n # Similarly, `segment_sizes` is a list of lists of segment lengths (empty lists for scalar-selected dimensions)\\n selection, segment_sizes = [], []\\n for dim_keep, dim_len in zip(keep, self.dataset.shape):\\n if np.isscalar(dim_keep):\\n # If selection is a scalar, pass directly to dataset selector and remove dimension from output\\n selection.append([(dim_keep, None, None)])\\n segment_sizes.append([])\\n elif isinstance(dim_keep, slice):\\n # If selection is a slice, pass directly to dataset selector without post-selection\\n start, stop, stride = dim_keep.indices(dim_len)\\n segm_size = len(range(start, stop, stride))\\n selection.append([(slice(start, stop, stride), slice(None), slice(0, segm_size, 1))])\\n segment_sizes.append([segm_size])\\n elif len(dim_keep) == 0:\\n # If selection is empty, pass to post-selector, as HDF5 datasets do not support zero-length selection\\n selection.append([(slice(0, 1, 1), slice(0, 0, 1), slice(0, 0, 1))])\\n segment_sizes.append([0])\\n else:\\n # Anything else is advanced indexing via bool or integer sequences\\n dim_keep = np.atleast_1d(dim_keep)\\n # Turn boolean mask into integer indices (True means keep that index)\\n if dim_keep.dtype == bool and len(dim_keep) == dim_len:\\n dim_keep = np.nonzero(dim_keep)[0]\\n elif not np.all(dim_keep == np.unique(dim_keep)):\\n raise TypeError('LazyIndexer cannot handle duplicate or unsorted advanced integer indices')\\n # Split indices into multiple contiguous segments (specified by first and one-past-last data indices)\\n jumps = np.nonzero(np.diff(dim_keep) > 1)[0]\\n first = [dim_keep[0]] + dim_keep[jumps + 1].tolist()\\n last = dim_keep[jumps].tolist() + [dim_keep[-1]]\\n segments = np.c_[first, np.array(last) + 1]\\n if len(dim_keep) > 0.2 * dim_len and len(segments) > 1:\\n # If more than 20% of data are selected in 2 or more separate segments (the Ratcliffian benchmark),\\n # select data at dataset level with a single slice spanning segments and then postselect the ndarray\\n selection.append([(slice(segments[0, 0], segments[-1, 1], 1),\\n dim_keep - dim_keep[0], slice(0, len(dim_keep), 1))])\\n segment_sizes.append([len(dim_keep)])\\n else:\\n # Turn each segment into a separate slice at dataset level without post-selection,\\n # and construct contiguous output slices of the same segment sizes\\n segm_sizes = [end - start for start, end in segments]\\n segm_starts = np.cumsum([0] + segm_sizes)\\n selection.append([(slice(start, end, 1), slice(None), slice(segm_starts[n], segm_starts[n + 1], 1))\\n for n, (start, end) in enumerate(segments)])\\n segment_sizes.append(segm_sizes)\\n # Short-circuit the selection if all dimensions are selected with scalars (resulting in a scalar output)\\n if segment_sizes == [[]] * ndim:\\n out_data = self.dataset[tuple([select[0][0] for select in selection])]\\n else:\\n # Use dense N-dimensional meshgrid to slice data set into chunks, based on segments along each dimension\\n chunk_indices = np.mgrid[[slice(0, len(select), 1) for select in selection]]\\n # Pre-allocate output ndarray to have the correct shape and dtype (will be at least 1-dimensional)\\n out_data = np.empty([np.sum(segments) for segments in segment_sizes if segments], dtype=self.dataset.dtype)\\n # Iterate over chunks, extracting them from dataset and inserting them into the right spot in output array\\n for chunk_index in chunk_indices.reshape(ndim, -1).T:\\n # Extract chunk from dataset (don't use any advanced indexing here, only scalars and slices)\\n dataset_select = tuple([select[segment][0] for select, segment in zip(selection, chunk_index)])\\n chunk = self.dataset[dataset_select]\\n # Perform post-selection on chunk (can be fancier / advanced indexing because chunk is now an ndarray)\\n post_select = [select[segment][1] for select, segment in zip(selection, chunk_index)]\\n # If any dimensions were dropped due to scalar indexing, drop them from post_select/out_select tuples\\n post_select = tuple([select for select in post_select if select is not None])\\n # Do post-selection one dimension at a time, as ndarray does not allow simultaneous advanced indexing\\n # on more than one dimension. This caters for the scenario where more than one dimension satisfies\\n # the Ratcliffian benchmark (the only way to get advanced post-selection).\\n for dim in range(len(chunk.shape)):\\n # Only do post-selection on this dimension if non-trivial (otherwise an unnecessary copy happens)\\n if not (isinstance(post_select[dim], slice) and post_select[dim] == slice(None)):\\n # Prepend the appropriate number of colons to the selection to place it at correct dimension\\n chunk = chunk[[slice(None)] * dim + [post_select[dim]]]\\n # Determine appropriate output selection and insert chunk into output array\\n out_select = [select[segment][2] for select, segment in zip(selection, chunk_index)]\\n out_select = tuple([select for select in out_select if select is not None])\\n out_data[out_select] = chunk\\n # Apply transform chain to output data, if any\\n return reduce(lambda data, transform: transform(data, original_keep), self.transforms, out_data)\",\n \"def find_proper_subsets(powerset, cardinality_difference = 1, debug = False):\\n subset_idx = [] # Which will be set A of the powerset\\n superset_idx = [] # Which will be set B of the powerset\\n\\n for A, a_idx in zip(powerset, list(range(0, len(powerset)))):\\n # A_is_proper_subset_of_B = True\\n for B, b_idx in zip(powerset[a_idx:], list(range(a_idx, len(powerset)))):\\n if len(A) is not len(B)-cardinality_difference:\\n continue\\n else: # Check every element\\n for a in A:\\n A_is_proper_subset_of_B = True\\n found_a_in_b = False\\n for b in B:\\n if a is b:\\n found_a_in_b = True\\n break\\n if found_a_in_b is False:\\n A_is_proper_subset_of_B = False\\n if A_is_proper_subset_of_B:\\n if debug:\\n print(\\\"A:\\\", A, \\\" is proper subset of B:\\\", B)\\n subset_idx.append(a_idx)\\n superset_idx.append(b_idx)\\n # return the indecees for the corresponding sets\\n #print(\\\"subset_idx: \\\", subset_idx)\\n #print(\\\"superset_idx: \\\", superset_idx)\\n return subset_idx, superset_idx\",\n \"def _select_fields(self):\\r\\n return []\",\n \"def get_slice(self, limit, offset):\\r\\n if limit == 0:\\r\\n return self.objects[offset:]\\r\\n\\r\\n return self.objects[offset:offset + limit]\",\n \"def __getslice__(self,i,j):\\n return self.x[i:j]\",\n \"def test_subset_reconstruction_iterable(self, wires):\\n circuit = hadamard_circuit(wires)\\n bits, recipes = circuit()\\n shadow = ClassicalShadow(bits, recipes)\\n\\n # choose 1000 random indices\\n snapshots = np.random.choice(np.arange(10000, dtype=np.int64), size=1000, replace=False)\\n state = shadow.global_snapshots(snapshots=snapshots)\\n assert state.shape == (len(snapshots), 2**wires, 2**wires)\\n\\n # check the results against obtaining the full global snapshots\\n expected = shadow.global_snapshots()\\n for i, t in enumerate(snapshots):\\n assert np.allclose(expected[t], state[i])\",\n \"def __getslice__(self, i, j):\\n return self.__getitem__(slice(i, j))\",\n \"def spatial_subset(dataset: xr.Dataset,\\n bbox: Tuple[float, float, float, float]) -> xr.Dataset:\\n x1, y1, x2, y2 = bbox\\n gm = GridMapping.from_dataset(dataset)\\n x_name, y_name = gm.xy_dim_names\\n return dataset.sel({\\n x_name: slice(x1, x2),\\n y_name: slice(y1, y2) if gm.is_j_axis_up else slice(y2, y1)\\n })\",\n \"def subset(dataset, article_indices):\\n indices = []\\n for a_id in article_indices:\\n indices += dataset.get_article_indices(a_id)\\n return Subset(dataset, indices)\",\n \"def get_subset(self, tile, band=0):\\r\\n # access window bounds\\r\\n bounds = rasterio.windows.bounds(tile, self.dataset.transform)\\r\\n return (\\r\\n self.__arr[(band,) + tile.toslices()],\\r\\n bounds,\\r\\n ) # Shape of array is announced with (bands, height, width)\\r\",\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 select_partial_data(self, anneal, my_data):\\n partial = anneal['partial']\\n\\n if partial == 0 or partial == 1: # partial == full data\\n return my_data\\n\\n my_N, D = my_data['y'].shape \\n my_pN = int(np.ceil(my_N * partial))\\n\\n if my_N == my_pN: # partial == full data\\n return my_data\\n\\n # Choose subset...\\n sel = np.random.permutation(my_N)[:my_pN]\\n sel.sort()\\n\\n # Construct partial my_pdata...\\n my_pdata = {}\\n for key, val in my_data.items():\\n my_pdata[key] = val[sel]\\n\\n return my_pdata\",\n \"def get_subtechniques_of():\\n global subtechniques_of\\n\\n if not subtechniques_of:\\n subtechniques_of = rsh.subtechniques_of(get_srcs())\\n \\n return subtechniques_of\",\n \"def properSubset(stack):\\n assertArity(stack, 2)\\n rhs, lhs = stack.pop(), stack.pop()\\n assertType(lhs, Set)\\n assertType(rhs, Set)\\n return lhs < rhs\",\n \"def subset(self, parameter_str, bounds):\\n # Copy range and prevent change of original\\n res_cov_range = copy.deepcopy(self)\\n\\n parameters = self.file2res.parameters\\n cov = res_cov_range.covariance\\n mpar = res_cov_range.mpar\\n # Create mask\\n mask1 = parameters[parameter_str] >= bounds[0]\\n mask2 = parameters[parameter_str] <= bounds[1]\\n mask = mask1 & mask2\\n res_cov_range.parameters = parameters[mask]\\n indices = res_cov_range.parameters.index.values\\n # Build subset of covariance\\n sub_cov_dim = len(indices)*mpar\\n cov_subset_vals = []\\n for index1 in indices:\\n for i in range(mpar):\\n for index2 in indices:\\n for j in range(mpar):\\n if index2*mpar+j >= index1*mpar+i:\\n cov_subset_vals.append(cov[index1*mpar+i,\\n index2*mpar+j])\\n\\n cov_subset = np.zeros([sub_cov_dim, sub_cov_dim])\\n tri_indices = np.triu_indices(sub_cov_dim)\\n cov_subset[tri_indices] = cov_subset_vals\\n\\n res_cov_range.file2res.parameters = parameters[mask]\\n res_cov_range.covariance = cov_subset\\n return res_cov_range\",\n \"def _get_family_slice(self, fam):\\n try:\\n return self._family_slice[fam]\\n except KeyError:\\n return slice(0, 0)\",\n \"def __get_slice(islice, isize):\\n if islice[0] is None:\\n if islice[1] is None:\\n return slice(isize)\\n else:\\n return slice(islice[1])\\n else:\\n if islice[1] is None:\\n return slice(islice[0], isize)\\n else:\\n return slice(islice[0], islice[1])\",\n \"def subset(stack):\\n assertArity(stack, 2)\\n rhs, lhs = stack.pop(), stack.pop()\\n assertType(lhs, Set)\\n assertType(rhs, Set)\\n return lhs <= rhs\",\n \"def subset(searchString):\\n print(f'📇 Download subset: {self.__repr__()}{\\\" \\\":60s}')\\n \\n outFile = self.get_local(searchString=searchString)\\n \\n if not overwrite and outFile.exists():\\n if verbose: print(f'🌉 Already have local copy --> {outFile}')\\n self.local_grib_subset = outFile\\n else:\\n # Download subsets of the file by byte range with cURL.\\n for i, (grbmsg, row) in enumerate(self.idx_df.iterrows()):\\n print(f\\\"{i+1:>4g}: GRIB_message={grbmsg:<3g} \\\\033[34m{row.variable}:{row.level}:{row.forecast_time}\\\\033[m\\\")\\n if i == 0:\\n # If we are working on the first item, overwrite the existing file...\\n curl = f'curl -s --range {row.range} {self.grib} > {outFile}'\\n else:\\n # ...all other messages are appended to the subset file.\\n curl = f'curl -s --range {row.range} {self.grib} >> {outFile}'\\n os.system(curl)\\n\\n self.local_grib_subset = outFile\",\n \"def get_design_parameters(self):\\n return self.__get_one_type_params(DesignParameter)\",\n \"def get_slice(self, node_id, nodes_in_slice, is_origin=False, is_reverse=False):\\n if is_reverse:\\n return self.get_reverse_slice(node_id, nodes_in_slice)\\n return self.get_level_element_slice(node_id, nodes_in_slice, is_origin=is_origin)\",\n \"def slice(self, field):\\n return [getattr(r, field) for r in self.__elements__]\",\n \"def intSubset(self):\\n ret = libxml2mod.xmlGetIntSubset(self._o)\\n if ret is None:raise treeError('xmlGetIntSubset() failed')\\n __tmp = xmlDtd(_obj=ret)\\n return __tmp\",\n \"def get_dataset_slice(\\n global_params, full_dataset, start_idx, size, dataset=None):\\n if size <= 0 or start_idx + size > full_dataset.num_points:\\n raise IndexError\\n if dataset is None:\\n dataset = Dataset()\\n dataset.num_points = size\\n dataset.init_aux_structures(global_params)\\n full_points_ref = full_dataset.get_ref('points')\\n dataset_points_ref = dataset.get_ref('points')\\n for i in range(size):\\n for j in range(global_params.dims):\\n dataset_points_ref[i][j] = full_points_ref[start_idx + i][j]\\n return dataset\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64185005","0.6416632","0.62816876","0.60458934","0.60294616","0.59579057","0.5831714","0.5782122","0.57754046","0.5741057","0.5671157","0.56486607","0.56307197","0.5624579","0.56143534","0.56012255","0.555921","0.55588406","0.54997003","0.54997003","0.5468571","0.5451591","0.54312056","0.54256725","0.54233","0.54139936","0.5373095","0.5372247","0.53586996","0.5356541","0.53425014","0.5340643","0.53300214","0.53206676","0.53140295","0.53114253","0.5297351","0.5291666","0.52872294","0.52806574","0.52733886","0.5266854","0.526372","0.5263079","0.5260384","0.5256491","0.52474904","0.5240233","0.52274656","0.52161247","0.5200756","0.51967955","0.5185112","0.51783985","0.5177892","0.516212","0.51576257","0.5157513","0.51356244","0.51353455","0.5121807","0.509707","0.50924873","0.50897086","0.5087074","0.5083094","0.50830364","0.5069171","0.50673145","0.50573313","0.50573313","0.5057153","0.5055727","0.50481325","0.5045915","0.504567","0.50331956","0.5022889","0.50194645","0.5016228","0.50158","0.5012953","0.500929","0.4997375","0.4992012","0.49880844","0.49872905","0.4979902","0.49793348","0.49760422","0.49651936","0.49619308","0.4960821","0.49600756","0.49456248","0.49315095","0.4926222","0.49217585","0.49204937","0.4920146","0.49167708"],"string":"[\n \"0.64185005\",\n \"0.6416632\",\n \"0.62816876\",\n \"0.60458934\",\n \"0.60294616\",\n \"0.59579057\",\n \"0.5831714\",\n \"0.5782122\",\n \"0.57754046\",\n \"0.5741057\",\n \"0.5671157\",\n \"0.56486607\",\n \"0.56307197\",\n \"0.5624579\",\n \"0.56143534\",\n \"0.56012255\",\n \"0.555921\",\n \"0.55588406\",\n \"0.54997003\",\n \"0.54997003\",\n \"0.5468571\",\n \"0.5451591\",\n \"0.54312056\",\n \"0.54256725\",\n \"0.54233\",\n \"0.54139936\",\n \"0.5373095\",\n \"0.5372247\",\n \"0.53586996\",\n \"0.5356541\",\n \"0.53425014\",\n \"0.5340643\",\n \"0.53300214\",\n \"0.53206676\",\n \"0.53140295\",\n \"0.53114253\",\n \"0.5297351\",\n \"0.5291666\",\n \"0.52872294\",\n \"0.52806574\",\n \"0.52733886\",\n \"0.5266854\",\n \"0.526372\",\n \"0.5263079\",\n \"0.5260384\",\n \"0.5256491\",\n \"0.52474904\",\n \"0.5240233\",\n \"0.52274656\",\n \"0.52161247\",\n \"0.5200756\",\n \"0.51967955\",\n \"0.5185112\",\n \"0.51783985\",\n \"0.5177892\",\n \"0.516212\",\n \"0.51576257\",\n \"0.5157513\",\n \"0.51356244\",\n \"0.51353455\",\n \"0.5121807\",\n \"0.509707\",\n \"0.50924873\",\n \"0.50897086\",\n \"0.5087074\",\n \"0.5083094\",\n \"0.50830364\",\n \"0.5069171\",\n \"0.50673145\",\n \"0.50573313\",\n \"0.50573313\",\n \"0.5057153\",\n \"0.5055727\",\n \"0.50481325\",\n \"0.5045915\",\n \"0.504567\",\n \"0.50331956\",\n \"0.5022889\",\n \"0.50194645\",\n \"0.5016228\",\n \"0.50158\",\n \"0.5012953\",\n \"0.500929\",\n \"0.4997375\",\n \"0.4992012\",\n \"0.49880844\",\n \"0.49872905\",\n \"0.4979902\",\n \"0.49793348\",\n \"0.49760422\",\n \"0.49651936\",\n \"0.49619308\",\n \"0.4960821\",\n \"0.49600756\",\n \"0.49456248\",\n \"0.49315095\",\n \"0.4926222\",\n \"0.49217585\",\n \"0.49204937\",\n \"0.4920146\",\n \"0.49167708\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12888,"cells":{"query":{"kind":"string","value":"Organize chip into readings per sample"},"document":{"kind":"string","value":"def samples(self):\n sample = {}\n for label, df in self.data.groupby(by='Sample'):\n sample[label] = Sample(label, df)\n return sample"},"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 samples(self):\n pass","def _read_cardiochip(self):\n cur_leadstatus = 0\n sample_count =0\n while self.connected:\n sample_count+=1\n #check for sync bytes\n readbyte = ord(self.ser.read(1))\n #print readbyte, SYNC_BYTE\n if readbyte != SYNC_BYTE:\n continue\n readbyte = ord(self.ser.read(1))\n if readbyte != SYNC_BYTE:\n continue\n\n #parse length byte\n while True:\n pLength = ord(self.ser.read(1))\n if pLength != SYNC_BYTE:\n break\n if pLength > 169:\n continue\n #print \"L: %i\" % pLength\n\n # collect payload bytes\n payload = self.ser.read(pLength)\n payload = [ord(x) for x in payload] #convert to int from string\n #print \"payload: \" + str(payload).strip('[]')\n # ones complement inverse of 8-bit payload sum\n checksum = sum(payload) & 0xFF\n checksum = ~checksum & 0xFF\n\n # catch and verify checksum byte\n chk = ord(self.ser.read(1))\n #print \"chk: \" + str(checksum)\n if chk != checksum:\n print \"checksum error, %i != %i\" % (chk, checksum)\n continue\n\n output = self._parseData(payload)\n\n lead_status = next(( d for d in output if 'leadoff' in d), None)\n if lead_status is not None:\n if cur_leadstatus != lead_status['leadoff']:\n #we have a change\n if lead_status['leadoff']==200:\n print \"LEAD ON\"\n elif lead_status['leadoff']==0:\n print \"LEAD OFF\"\n cur_leadstatus = lead_status['leadoff']\n\n # store the output data in a queue\n # first, create a tuple with the sample index and dict with the timestamp and ecg\n ecgdict = next(((i,d) for i,d in enumerate(output) if 'ecg_raw' in d), None)\n if ecgdict is not None and sample_count>self.Fs*2:\n #let's just ignore the first 2 seconds of crappy data\n ecgdict[1]['leadoff'] = cur_leadstatus\n #print ecgdict[1]\n self.ecg_buffer.put(ecgdict[1]) # this should save the ecg and timestamp keys\n\n return","def addSamples(file, spec, data_card, channel_bins, samples, shapefile):\n data_card.processes = samples\n\n for idxc, channel in enumerate(spec[\"channels\"]):\n if data_card.hasShapes == False: # counting\n for sample in channel[\"samples\"]:\n data_card.exp[channel[\"name\"]].update(\n {sample[\"name\"]: sample[\"data\"][0]}\n )\n else:\n # shapes\n data_card.shapeMap.update({channel[\"name\"]: {}})\n data_card.shapeMap[channel[\"name\"]].update(\n {\"data_obs\": [shapefile, channel[\"name\"] + \"/\" + \"data_obs\"]}\n )\n for idxs, sample in enumerate(channel[\"samples\"]):\n data = sum(sample[\"data\"])\n data_card.exp[channel[\"name\"]].update({sample[\"name\"]: data})\n\n mods = [\n spec[\"channels\"][idxc][\"samples\"][idxs][\"modifiers\"][i][\"type\"]\n for i, mod in enumerate(\n spec[\"channels\"][idxc][\"samples\"][idxs][\"modifiers\"]\n )\n ]\n if \"histosys\" in mods:\n # if shape uncertainty histogram is available\n data_card.shapeMap[channel[\"name\"]].update(\n {\n spec[\"channels\"][idxc][\"samples\"][idxs][\"name\"]: [\n shapefile,\n channel[\"name\"]\n + \"/\"\n + spec[\"channels\"][idxc][\"samples\"][idxs][\"name\"],\n channel[\"name\"]\n + \"/\"\n + spec[\"channels\"][idxc][\"samples\"][idxs][\"name\"]\n + \"_$SYSTEMATIC\",\n ]\n }\n )\n else:\n data_card.shapeMap[channel[\"name\"]].update(\n {\n spec[\"channels\"][idxc][\"samples\"][idxs][\"name\"]: [\n shapefile,\n channel[\"name\"]\n + \"/\"\n + spec[\"channels\"][idxc][\"samples\"][idxs][\"name\"],\n ]\n }\n )\n if \"staterror\" in mods:\n # if staterror is present, provide variances for histograms\n h_data = hist.Hist.new.Regular(\n channel_bins[channel[\"name\"]], 0, channel_bins[channel[\"name\"]]\n ).Weight()\n\n h_data[...] = np.stack(\n [\n spec[\"channels\"][idxc][\"samples\"][idxs][\"data\"],\n [\n i**2\n for i in spec[\"channels\"][idxc][\"samples\"][idxs][\n \"modifiers\"\n ][mods.index(\"staterror\")][\"data\"]\n ],\n ],\n axis=-1,\n )\n data_card.binParFlags.update({channel[\"name\"]: True})\n elif \"shapesys\" in mods: # for shapesys, also provide variances\n h_data = hist.Hist.new.Regular(\n channel_bins[channel[\"name\"]], 0, channel_bins[channel[\"name\"]]\n ).Weight()\n h_data[...] = np.stack(\n [\n spec[\"channels\"][idxc][\"samples\"][idxs][\"data\"],\n [\n i**2\n for i in spec[\"channels\"][idxc][\"samples\"][idxs][\n \"modifiers\"\n ][mods.index(\"shapesys\")][\"data\"]\n ],\n ],\n axis=-1,\n )\n data_card.binParFlags.update({channel[\"name\"]: True})\n else: # no staterror or shapesys->0 variance\n h_data = hist.Hist.new.Regular(\n channel_bins[channel[\"name\"]], 0, channel_bins[channel[\"name\"]]\n ).Weight()\n h_data[...] = np.stack(\n [\n spec[\"channels\"][idxc][\"samples\"][idxs][\"data\"],\n [0 for _ in range(channel_bins[channel[\"name\"]])],\n ],\n axis=-1,\n )\n file[\n channel[\"name\"]\n + \"/\"\n + spec[\"channels\"][idxc][\"samples\"][idxs][\"name\"]\n ] = h_data","def get_next_sample(self):","def get_cui_sample_it(self):\n while True:\n i = rd.sample(range(len(self.id2sense)), 1)[0]\n cui = self.id2sense[i]\n if cui in self.cui2def:\n sdef = self.cui2def[cui]\n else:\n sdef = [self.voc.encode(PAD)] * self.model_config.max_def_len\n\n if cui in self.cui2stype:\n stype = self.cui2stype[cui]\n else:\n stype = self.stype2id['unk']\n\n for abbr_id in self.cuiud2abbrid[i]:\n obj = {\n 'abbr_id': abbr_id,\n 'cui_id': i,\n 'def': sdef,\n 'stype': stype}\n yield obj","def repackageSamples(pinsToMeasure, pinMap, nMilliBlocks, samples):\n\n channels = [None, None, None, None]\n for pinName in pinsToMeasure:\n channels[pinMap[pinName]] = ( { \"pinName\": pinName, \"isAudio\": isAudio(pinName), \"min\": [], \"max\": [] } )\n\n i = 0\n for blk in range(0, nMilliBlocks):\n for channel in channels:\n if channel != None:\n channel[\"max\"].append(ord(samples[i]))\n i += 1\n channel[\"min\"].append(ord(samples[i]))\n i += 1\n\n return channels","def getBarySamples(self):\n self.XC1Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.XC2Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.c1Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.c2Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.c3Fields = np.zeros([self.nSample, self.nCell_cfd])\n\n for isamp in np.arange(self.nSample):\n TauNew = self.TauSample[isamp, :, :]\n k,V1,V2,V3,C,NP = self.mapTau._tau2PhysParams(TauNew)\n X = self.mapTau._C2X(C)\n \n self.c1Fields[isamp, :] = C[:, 0]\n self.c2Fields[isamp, :] = C[:, 1]\n self.c3Fields[isamp, :] = C[:, 2]\n \n \n self.XC1Fields[isamp, :] = X[:, 0]\n self.XC2Fields[isamp, :] = X[:, 1]\n \n # Get base C1 and C2 field\n k,V1,V2,V3,C,NP = self.mapTau._tau2PhysParams(self.Taubar)\n X = self.mapTau._C2X(C)\n \n self.c1Field_base = C[:, 0]\n self.c2Field_base = C[:, 1]\n self.c3Field_base = C[:, 2]\n\n self.XC1Field_base = X[:, 0]\n self.XC2Field_base = X[:, 1] \n\n np.savetxt(self.resultDir+'RComponent_samples/XC1_s', self.XC1Fields)\n np.savetxt(self.resultDir+'RComponent_samples/XC2_s', self.XC2Fields)\n np.savetxt(self.resultDir+'RComponent_samples/XC1_base', self.XC1Field_base)\n np.savetxt(self.resultDir+'RComponent_samples/XC2_base', self.XC2Field_base)\n\n np.savetxt(self.resultDir+'RComponent_samples/c1_s', self.c1Fields)\n np.savetxt(self.resultDir+'RComponent_samples/c2_s', self.c2Fields)\n np.savetxt(self.resultDir+'RComponent_samples/c3_s', self.c3Fields) \n np.savetxt(self.resultDir+'RComponent_samples/c1_base', self.c1Field_base)\n np.savetxt(self.resultDir+'RComponent_samples/c2_base', self.c2Field_base) \n np.savetxt(self.resultDir+'RComponent_samples/c3_base', self.c3Field_base)","def __getitem__(self, item):\n c_ex = self.examples[item]\n # randomly select ref mic\n mics = [x for x in c_ex.keys()]\n if self.train:\n np.random.shuffle(mics) # randomly permute during training to change ref mics\n\n mixtures = []\n sources = []\n for i in range(len(mics)):\n c_mic = c_ex[mics[i]]\n\n if self.segment:\n offset = 0\n if c_mic[\"length\"] > int(self.segment * self.sample_rate):\n offset = np.random.randint(\n 0, c_mic[\"length\"] - int(self.segment * self.sample_rate)\n )\n\n # we load mixture\n mixture, fs = sf.read(\n c_mic[\"mixture\"],\n start=offset,\n stop=offset + int(self.segment * self.sample_rate),\n dtype=\"float32\",\n )\n spk1, fs = sf.read(\n c_mic[\"spk1\"],\n start=offset,\n stop=offset + int(self.segment * self.sample_rate),\n dtype=\"float32\",\n )\n spk2, fs = sf.read(\n c_mic[\"spk2\"],\n start=offset,\n stop=offset + int(self.segment * self.sample_rate),\n dtype=\"float32\",\n )\n else:\n mixture, fs = sf.read(c_mic[\"mixture\"], dtype=\"float32\") # load all\n spk1, fs = sf.read(c_mic[\"spk1\"], dtype=\"float32\")\n spk2, fs = sf.read(c_mic[\"spk2\"], dtype=\"float32\")\n\n mixture = torch.from_numpy(mixture).unsqueeze(0)\n spk1 = torch.from_numpy(spk1).unsqueeze(0)\n spk2 = torch.from_numpy(spk2).unsqueeze(0)\n\n assert fs == self.sample_rate\n mixtures.append(mixture)\n sources.append(torch.cat((spk1, spk2), 0))\n\n mixtures = torch.cat(mixtures, 0)\n sources = torch.stack(sources)\n # we pad till max_mic\n valid_mics = mixtures.shape[0]\n if mixtures.shape[0] < self.max_mics:\n dummy = torch.zeros((self.max_mics - mixtures.shape[0], mixtures.shape[-1]))\n mixtures = torch.cat((mixtures, dummy), 0)\n sources = torch.cat((sources, dummy.unsqueeze(1).repeat(1, sources.shape[1], 1)), 0)\n return mixtures, sources, valid_mics","def sample(self):\n raise NotImplementedError","def sample(self):\n raise NotImplementedError","def sample(self):\r\n raise NotImplementedError","def activatePinReading(self):\n\n for pin in self.pinsToMeasure:\n arduino.samplePinDuringCapture(self.f, self.pinMap[pin], self.wallClock)","def render(self, downsamp=1):\n \n # first determine if time is provided, if not assume all start at zero\n # and last the duration of sonification\n\n if \"time\" not in self.sources.mapping:\n self.sources.mapping['time'] = [0.] * self.sources.n_sources\n self.sources.mapping['note_length'] = [self.score.length] * self.sources.n_sources\n \n # index each chord\n cbin = np.digitize(self.sources.mapping['time'], self.score.fracbins, 0)\n cbin = np.clip(cbin-1, 0, self.score.nchords-1)\n\n # pitch rank of each source divided by the number of sources\n pitchfrac = np.empty_like(self.sources.mapping['pitch'])\n pitchfrac[np.argsort(self.sources.mapping['pitch'])] = np.arange(self.sources.n_sources)/self.sources.n_sources\n\n # get some relevant numbers before iterating through sources\n Nsamp = self.out_channels['0'].values.size\n lastsamp = Nsamp - 1\n Nchan = len(self.out_channels.keys())\n indices = range(0,self.sources.n_sources, downsamp)\n\n for source in tqdm(indices):\n\n # index note properties\n t = self.sources.mapping['time'][source]\n tsamp = int(Nsamp * t)\n chord = self.score.note_sequence[cbin[source]]\n nints = self.score.nintervals[cbin[source]]\n pitch = pitchfrac[source]\n note = chord[int(pitch * nints)]\n # make dictionary for feeding to play function with each notes properties\n sourcemap = {}\n # for k in self.sources.mapping.keys():\n # sourcemap[k] = self.soures.mapping[k][source]\n nested_dict_idx_reassign(self.sources.mapping, sourcemap, source)\n sourcemap['note'] = note\n\n # run generator to play each note\n sstream = self.generator.play(sourcemap)\n playlen = sstream.values.size\n if 'phi' in sourcemap:\n phi = const_or_evo(sourcemap['phi'], sstream.sampfracs) * 2 * np.pi\n else:\n phi = const_or_evo(self.generator.preset['phi'], sstream.sampfracs) * 2 * np.pi\n if 'theta' in sourcemap:\n theta = const_or_evo(sourcemap['theta'], sstream.sampfracs) * np.pi\n else:\n theta = const_or_evo(self.generator.preset['theta'], sstream.sampfracs) * np.pi\n\n # compute sample indices for truncating notes overshooting sonification length\n trunc_note = min(playlen, lastsamp-tsamp)\n trunc_soni = trunc_note + tsamp\n\n # spatialise audio by computing relative volume in each speaker\n for i in range(Nchan):\n panenv = self.channels.mics[i].antenna(phi,theta)\n self.out_channels[str(i)].values[tsamp:trunc_soni] += (sstream.values*panenv)[:trunc_note]","def generate_synth_data(n):","def sample(self, verbose=False):\n\t\tfor i in range(self.nsamp): self.subsample(verbose)\n\t\treturn self.amps, self.pos, self.irads","def generate_samples(self, n_samples):","def generate_samples(self, n_samples):","def downsample_sam(self, factor):","def _group_samples_by_channel(self):\n samples_acquired_per_channel = len(self.all_samples_list) / self.num_channels\n\n #make a list with each element being a numpy array for the results from each channel\n channel_data = []\n for i in range(self.num_channels):\n channel_data.append(numpy.zeros(samples_acquired_per_channel,dtype=float))\n\n scan_num = 0\n channel_index = 0\n for sample in range(len(self.all_samples_list)): #each sample in interleaved list\n channel_data[channel_index][scan_num] = self.all_samples_list[sample]\n if channel_index < self.num_channels-1:\n channel_index += 1\n else:\n channel_index = 0\n scan_num += 1\n\n if self.num_channels == 1: #if only one channel put the numpy array on the queue\n self.result_queue.put(channel_data[0])\n else: #if more than one channel put the list of arrays on the queue\n self.result_queue.put(channel_data)","def test_random_reads_chs(demo_data):\n\n fetches = 10\n chs = [1,3]\n pyeeg = pyEDF(demo_data)\n openeeg = openEDF(demo_data)\n openeeg.channels = chs\n\n #build fetch numbers of start and stop sample indices\n starts = np.random.randint(0, 5e6, fetches)\n stops = starts + np.random.randint(0, 5e5)\n \n for start, stop in zip(starts, stops):\n arr = openeeg.read(start, stop)\n other = pyread(pyeeg, start, stop, channels=chs)\n assert np.allclose(arr, other)\n\n pyeeg.close()\n openeeg.close()","def sample(self):","def produce_features(self, chip):\n raise NotImplementedError(\"produce_features() not implemented\")","def create_shard(dataset, num_shards):\n input_chips, label_chips = [], []\n for item in tqdm(dataset):\n # not using chip_id and chip_for_display fields\n input_chips.append(item['chip'])\n label_chips.append(item['chip_label'])\n\n # debugging\n # if len(input_chips) > 200:\n # break\n num_chips = len(input_chips)\n print(f'Created {num_chips} chips.')\n\n items_per_shards = math.ceil(num_chips / num_shards)\n shard_idx = []\n for i in range(num_shards):\n shard_idx.append(\n (i * items_per_shards, (1 + i) * items_per_shards)\n )\n # print(f'Debug - shard_end_idx is {shard_idx}')\n\n print('Stacking imagery and label chips into shards')\n input_chip_shards, label_chip_shards = [], []\n for begin_idx, end_idx in shard_idx:\n if begin_idx < num_chips:\n input_chip_shard = input_chips[begin_idx:end_idx]\n input_chip_shard = np.stack(input_chip_shard, axis=0)\n print(f'dim of input chip shard is {input_chip_shard.shape}, dtype is {input_chip_shard.dtype}')\n input_chip_shards.append(input_chip_shard)\n\n label_chip_shard = label_chips[begin_idx:end_idx]\n label_chip_shard = np.stack(label_chip_shard, axis=0)\n print(f'dim of label chip shard is {label_chip_shard.shape}, dtype is {label_chip_shard.dtype}')\n label_chip_shards.append(label_chip_shard)\n\n return (input_chip_shards, label_chip_shards)","def _choose_sample(self):\n\n \t #periodically generate a new reconstruction for the purposes of sampling","def __set_chips(self):\n\n # Scan filesystem\n root_files = [root_file for root_file in os.walk(self.dataset_path)]\n\n # Decode truth.txt file\n truth_files = [os.path.join(walked[0], 'truth.txt') for walked in root_files if 'truth.txt' in walked[2]]\n if len(truth_files) == 0:\n raise IOError(\"No truth file found.\")\n elif len(truth_files) > 1:\n raise IOError(\"Too many truth files available.\")\n\n truth_data = self.__decode_truth_file(truth_files.pop())\n if len(truth_data) < 1:\n raise IOError(\"No truth loaded\")\n if self.__debug:\n print(\"{} truth records loaded.\".format(len(truth_data)))\n\n # Index all image chips\n file_paths = [[os.path.join(walked[0], wfile) for wfile in walked[2]] for walked in root_files]\n chip_idx = dict(filter(lambda t: t is not None, map(self.__index_chip, itertools.chain(*file_paths))))\n\n if len(chip_idx) != len(truth_data):\n raise IOError(\"Number of truth records not equal to number of chips.\")\n if self.__debug:\n print(\"{} image chips loaded.\".format(len(chip_idx)))\n\n # Create and store chips\n self.chips = {meta['file']: self.__create_chip(meta, truth_data[idx]) for idx, meta in chip_idx.items()}\n if self.__debug:\n print(\"{} chip.Chips loaded.\".format(len(self.chips)))","def hires_read_1chip(hdu,chipno):\n\n # Extract datasec from header\n datsec = hdu[chipno].header['DATASEC']\n detsec = hdu[chipno].header['DETSEC']\n postpix = hdu[0].header['POSTPIX']\n precol = hdu[0].header['PRECOL']\n\n x1_dat, x2_dat, y1_dat, y2_dat = np.array(parse.load_sections(datsec)).flatten()\n x1_det, x2_det, y1_det, y2_det = np.array(parse.load_sections(detsec)).flatten()\n\n # This rotates the image to be increasing wavelength to the top\n #data = np.rot90((hdu[chipno].data).T, k=2)\n #nx=data.shape[0]\n #ny=data.shape[1]\n\n # Science data\n fullimage = hdu[chipno].data\n data = fullimage[x1_dat:x2_dat,y1_dat:y2_dat]\n\n # Overscan\n oscan = fullimage[:,y2_dat:]\n\n # Flip as needed\n if x1_det > x2_det:\n data = np.flipud(data)\n oscan = np.flipud(oscan)\n if y1_det > y2_det:\n data = np.fliplr(data)\n oscan = np.fliplr(oscan)\n\n # Return\n return data, oscan","def sample(read_sampler, n, array, res=1.0, prng = np.random.RandomState()):\n for read in read_sampler.pull_reads(n, prng):\n map_read(array, read, res)","def read_sample(sample_path):\n files = os.listdir(sample_path)\n json_path = [f for f in files if f.endswith('_read-info.json')]\n assert len(json_path) == 1, 'There should be exactly 1 *_read-info.json file in the sample (.smpl)'\n # get base for sample\n with open(os.path.join(sample_path, json_path[0]), 'r') as f:\n sample = json.load(f)\n # get sample info\n info_path = [f for f in files if f.endswith('info.csv')]\n assert len(info_path) == 1, 'There should be exactly 1 *_info.csv file in the sample (.smpl)'\n sample['info'] = pd.read_csv(os.path.join(sample_path, info_path[0]))\n info_path = os.path.join(sample_path, info_path[0])\n # get individual sample\n regex = re.compile(r'id-\\d*_t-\\d*')\n pairs = [f for f in files if len(regex.findall(f)) > 0]\n for str_pair in pairs:\n pair_dir = os.path.join(sample_path, str_pair)\n pair_dict = {}\n # get df\n df_path = os.path.join(pair_dir, str_pair + '_df.csv')\n pair_dict['df'] = pd.read_csv(df_path)\n pair_dict['df_path'] = df_path\n pair_dict['info_path'] = info_path\n # get tracks\n tracks_path = os.path.join(pair_dir, str_pair + '_tracks.zarr')\n pair_dict['tracks'] = zarr.open(tracks_path)\n # get b_box\n bbox_path = os.path.join(pair_dir, str_pair + '_bbox.json')\n with open(bbox_path, 'r') as f:\n bbox = json.load(f)\n new_bbox = {}\n for key in bbox.keys():\n args = list(bbox[key])\n new_bbox[key] = slice(*args)\n pair_dict['b_box'] = new_bbox\n # find out if corrs exist and read if so\n corr_path = [f for f in os.listdir(pair_dir) if f.endswith('_corr.json')]\n if len(corr_path) > 0:\n with open(os.path.join(pair_dir, corr_path[0]), 'r') as f:\n corr = json.load(f)\n pair_dict['corr'] = corr\n # if image exists, read\n img_path = os.path.join(pair_dir, str_pair + '_image.zarr')\n if os.path.exists(img_path):\n img = zarr.open(img_path)\n #print(img, img_path)\n pair_dict['image'] = img\n # if labels exist, read\n lab_path = os.path.join(pair_dir, str_pair + '_labels.zarr')\n if os.path.exists(lab_path):\n lab = zarr.open(lab_path)\n #print(lab.shape)\n pair_dict['labels'] = lab\n # add pair to sample\n id_re = re.compile(r'id-\\d*')\n ID = id_re.findall(str_pair)[0][3:]\n t_re = re.compile(r't-\\d*')\n t = t_re.findall(str_pair)[0][2:]\n pair = (int(ID), int(t))\n sample[pair] = pair_dict\n #print(str_pair, pair)\n #print(list(sample.keys()))\n #print(list(sample[eval(pairs[0])].keys()))\n return sample","def split(filepath, nsamples):\n start = np.cumsum([0] + list(nsamples[:-1]))\n if filepath[-10:] == 'analog.brw':\n filename = filepath[:-10]\n analog = read_3brain_analog(filepath)\n for i, (s,n) in enumerate(zip(start, nsamples)):\n name = f\"{filename}_part_{i}_analog.npz\"\n print(f\"Saving {name}\")\n sampling_rate = glia.sampling_rate(filepath)\n np.savez(name, analog=analog[s:s+n],\n sampling_rate=sampling_rate)\n elif filepath[-4:] == \".bxr\":\n filename = filepath[:-4]\n # split spike-sorted data\n with h5py.File(filepath, 'r') as h5:\n # shared setup for the concatenated arrays\n sampling_rate = float(h5[\"3BRecInfo\"][\"3BRecVars\"][\"SamplingRate\"][0])\n channel_map = h5[\"3BRecInfo\"][\"3BMeaStreams\"][\"Raw\"][\"Chs\"][()]\n \n # map 3brain unit num\n # numbers typically from -4 to 9000\n # where negative numbers appear across multiple channels\n # and thus are presumably bad units...?\n # positive-numbered units appear on one channel\n unit_id_2_num = {}\n\n n_unit_nums = 0\n if \"SpikeUnits\" in h5[\"3BResults\"][\"3BChEvents\"]:\n for chunk in iter_chunks(h5['3BResults/3BChEvents/SpikeUnits'], 10000):\n n_unit_nums = max(n_unit_nums, chunk.max())\n \n unit_map = {}\n channel_unit_count = {}\n\n\n # operate on each of the concatenated arrays, one at a time\n for i, (s,n) in enumerate(zip(start, nsamples)):\n startTime = s / sampling_rate\n first_idx = None\n for chunk in iter_chunks(h5['3BResults/3BChEvents/SpikeTimes'], 10000):\n valid_idxs = np.argwhere(h5[\"3BResults/3BChEvents/SpikeTimes\"] > s)\n if len(valid_idxs) > 0:\n first_idx = valid_idxs[0][0]\n break\n assert not first_idx is None\n print(f\"identified start idx of {first_idx}.\")\n\n # for simplicity, we just iterate again, could have faster implementation\n last_idx = len(h5['3BResults/3BChEvents/SpikeTimes'])\n chunk_size = 10000\n for j, chunk in enumerate(iter_chunks(h5['3BResults/3BChEvents/SpikeTimes'], chunk_size)):\n invalid_idxs = np.argwhere(chunk > s + n)\n if len(invalid_idxs) > 0:\n last_idx = invalid_idxs[0][0] + j*chunk_size\n break\n print(f\"identified stop idx of {last_idx}.\")\n \n spike_channel_ids = h5[\"3BResults\"][\"3BChEvents\"][\"SpikeChIDs\"][first_idx:last_idx]\n spike_unit_ids = h5[\"3BResults\"][\"3BChEvents\"][\"SpikeUnits\"][first_idx:last_idx]\n # poorly named; time is in units of 1/sampling_rate\n # aka sample number\n # subtract to adjust start time\n spike_times = h5[\"3BResults\"][\"3BChEvents\"][\"SpikeTimes\"][first_idx:last_idx] - s\n \n\n \n csv_name = f'{filename}_part_{i}_spikes.csv'\n spikes = zip(spike_channel_ids, spike_unit_ids, spike_times)\n tot_spikes = spike_times.shape[0]\n print(f\"creating {csv_name} ...\")\n with open(csv_name, 'w', newline='') as csvfile:\n fieldnames = ['channel_i', 'channel_j', 'unit', \"spike_time\"]\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n\n writer.writeheader()\n for channel, unit_id, spike_time in tqdm(spikes,\n total=tot_spikes):\n c = channel_map[channel]\n # convert to tuple\n # account for 1-indexing\n c = (c[0]-1,c[1]-1)\n \n # count num units on channel\n # first check if we've seen this channel before\n if not c in channel_unit_count:\n # if not, initialize channel_unit_count for the channel\n channel_unit_count[c] = 1\n unit_num = 0\n # add unit\n unit_id_2_num[unit_id] = unit_num\n else:\n \n # then check if we've seen this unit before\n if not unit_id in unit_id_2_num:\n # if not, assign unit_num for this new unit\n unit_num = channel_unit_count[c]\n unit_id_2_num[unit_id] = unit_num\n channel_unit_count[c] += 1\n else:\n # otherwise, look it up\n unit_num = unit_id_2_num[unit_id]\n \n \n t = spike_time / sampling_rate\n writer.writerow({\"channel_i\": c[0],\n \"channel_j\": c[1],\n \"unit\": unit_num,\n \"spike_time\": t})\n \n np.save(f\"{filename}_channel_map.npy\", channel_map)","def _compute_samples(self, samples):\n return samples","def features_combine():\n\n\n\t# PROCESSING AUDIO","def chip_image1(img, chip_size=(300, 300)):\n width, height, _ = img.shape\n wn, hn = chip_size\n images = np.zeros((int(width / wn) * int(height / hn), wn, hn, 3))\n k = 0\n for i in tqdm(range(int(width / wn))):\n for j in range(int(height / hn)):\n chip = img[wn * i:wn * (i + 1), hn * j:hn * (j + 1), :3]\n images[k] = chip\n\n k = k + 1\n\n return images.astype(np.uint8)","def magic_sample(self, ys):\n\n #for each non-zero element in y\n #we want to multiply the initial state by HGate(i) SGate(i) HGate(i)\n #this turns out to be equivalent to multiplying the whole final state by\n #U H_k S_k H_k U^\\dagger\n #but H_k S_k H_k = e^{i\\pi/4} \\frac{1}{\\sqrt{2}} (I -i X_k)\n #so now we evolve identity forward by U (trivial)\n #and evolve X_k forward by U (using the AGState)\n #then we have to send the resulting Pauli through UC and UH\n #giving a third Pauli\n #then the state is of the form (we^{i\\pi/4}) UC UH (I + i^d P)/sqrt(2) |s>\n #then we apply Bravyi et al's prop. 4 to turn this into a new ch form\n \n\n chCopy = deepcopy(self.chState) #we update this copy as we go\n\n for i, y in enumerate(ys):\n if y:\n #we want to know what U_c^\\dagger U X_i U^\\dagger U_c is\n #firstly we use the A-G info\n # U X_i U^\\dagger is the i'th destabiliser\n x = self.agState.x[self.n+i]\n z = self.agState.z[self.n+i]\n r = self.agState.r[self.n+i]\n\n #print(x,z,r)\n x_col = np.array([x]).T\n z_col = np.array([z]).T\n \n #now we apply U_c to this using the CH-form info\n x_mat = chCopy.F * x_col\n z_mat = (chCopy.M * x_col + chCopy.G*z_col) % np.uint8(2)\n r = (r + util.sort_pauli_string(x_mat, z_mat)) % np.uint8(2)\n\n u = (x @ chCopy.F) % np.uint8(2)\n h = (x @ chCopy.M + z @ chCopy.G) % np.uint8(2)\n\n g = (x @ (z + chCopy.g)) % np.uint8(4)\n\n #now U_c^dag U X_i U^dag U_C = (-1)^r i^g prod_j Z_j^{h_j} X_j^{u_j}\n #we want to conjugate this by U_H\n #everywhere chCopy.v == 1 we flip a z to an x and an x to a z\n #everywhere chCopy.v == 1 and u == 1 and h == 1 we need to swap the order of our x and z so we get a minus sign\n\n u2 = u*(np.uint8(1) ^ chCopy.v) ^ (h*chCopy.v)\n h2 = (u*chCopy.v) ^ (h*(np.uint8(1) ^ chCopy.v))\n\n r = (r + (u*h*chCopy.v).sum()) % np.uint8(2)\n \n \n #now U_H^dag U_c^dag U X_i U^dag U_C U_H = (-1)^r i^g prod_j Z_j^{h2_j} X_j^{u2_j}\n\n t = u2 ^ chCopy.s\n r = (r + h2 @ t) % np.uint8(2)\n\n #now we have w UC UH |s> = w (-1)^r (i)^g UC UH |t>\n\n if all(t == chCopy.s):\n chCopy.w *= np.exp(1j*np.pi/4) * (1 + (1j)**(g+2*r -1) )/ np.sqrt(2)\n else:\n phase, VCList, v, s = util.desuperpositionise(chCopy.s, t, (g+2*r -1)%np.uint8(4), chCopy.v)\n\n chCopy.w *= phase*np.exp(1j*np.pi/4)/np.sqrt(2)\n chCopy.v = v\n chCopy.s = s\n\n for gate in VCList:\n gate.rightMultiplyC(chCopy)\n \n return chCopy","def init_devices(self):\n self.hp_nb = int(self.rs_nb* self.hp_proportion/(1- self.hp_proportion))\n self.defense_cost = self.hp_nb * self.hp_unit_cost\n rs_devices = [True for i in range(self.rs_nb)] #rs --> True\n hp_devices = [False for i in range(self.hp_nb)] #hp --> False\n self.devices = rs_devices + hp_devices\n shuffle(self.devices)","def next_batch(self):\n sp, noise, mix = super().next_batch()\n\n if sp.shape != noise.shape or sp.shape != mix.shape:\n raise Exception(\"ERROR: sp.shape != noise.shape or sp.shape != mix.shape\")\n\n batch_size, frames, bins = mix.shape\n\n mix_feat = chimera_preprocess(mix)\n mix_clean = np.abs(mix)\n\n # Get dominant spectra indexes, create one-hot outputs\n M = np.zeros(mix.shape + (2,), dtype=np.float32)\n M[:, :, :, 0] = (abs(sp) >= abs(noise))\n M[:, :, :, 1] = (abs(sp) < abs(noise))\n\n M_clean = np.zeros(mix.shape + (2,), dtype=np.float32)\n M_clean[:, :, :, 0] = np.abs(sp)\n M_clean[:, :, :, 1] = np.abs(noise)\n\n return mix_feat, mix_clean, M, M_clean","def read_and_display_data(hat, samples_per_channel, num_channels): \n \n # Read all of the available samples (up to the size of the read_buffer which\n # is specified by the user_buffer_size). Since the read_request_size is set\n # to -1 (READ_ALL_AVAILABLE), this function returns immediately with\n # whatever samples are available (up to user_buffer_size) and the timeout\n # parameter is ignored.\n total_samples_read = 0\n read_request_size = READ_ALL_AVAILABLE\n completeFlag = 0 \n timeout = 5.0\n \n # file switch: w = Write to a file\n # file switch: w+ = Write to a file, if it doesn't exist create it\n # file switch: a = Append to a file\n # file switch: a+ = Append to a file, if is doesn't exist create it.\n # file switch: x = will create a file, returns an error if the file exist\n \n\n # If the scan starts, create a file name based upon current date and time.\n # Retrieve the Current Working Directory and generate the full path \n # to where to write the collected data as a .csv file. Open the file \n # begin writing the data to the file. When done, close the file.\n \n try:\n if os.path.exists(basepath):\n if not (os.path.exists(mypath)):\n os.mkdir(mypath)\n else:\n os.mkdir(basepath)\n os.chdir(basepath)\n os.mkdir(mypath)\n except OSError as exc:\n raise\n \n os.chdir(mypath)\n fileDateTime = datetime.strftime(datetime.now(), \"(%m_%d_%Y)-(%H-%M-%S)\")\n #filePath = mypath + \"/\" + DAQ_NAME + \"_\" + fileName + \".csv\"\n filePath = mypath + \"/\" + DAQ_NAME + \"_\" + fileDateTime + \".csv\"\n csvfile = open(filePath, \"w+\")\n csvwriter = csv.writer(csvfile) \n \n # Recording LED\n GPIO.setmode(GPIO.BCM)\n GPIO.setup(RECORDING_LED, GPIO.OUT, initial=GPIO.LOW)\n GPIO.output(RECORDING_LED,GPIO.HIGH)\n \n while total_samples_read < samples_per_channel:\n read_result = hat.a_in_scan_read(read_request_size, timeout)\n\n # Check for an overrun error\n if read_result.hardware_overrun:\n print('\\n\\nHardware overrun\\n')\n break\n elif read_result.buffer_overrun:\n print('\\n\\nBuffer overrun\\n')\n break\n elif not (read_result.running and completeFlag == 0):\n completeFlag = 1\n print('\\n (2) Recording Completed - Buffer Draining')\n\n samples_read_per_channel = int(len(read_result.data) / num_channels)\n total_samples_read += samples_read_per_channel\n \n totalSamples = len(read_result.data) \n\n if samples_read_per_channel > 0:\n index = samples_read_per_channel * num_channels - num_channels\n \n new_index = 0\n myArray=[] #create an empty array\n for i in range(0, totalSamples, num_channels):\n myArray.append([]) #add a row to the array (COLUMN)\n for j in range(num_channels):\n\t\t\t\t\t#append a num_channels of data to the array (ROW)\n myArray[new_index].append(read_result.data[i + j]) \n new_index+=1\n\n csvwriter.writerows(myArray) #Write the array to file\n csvfile.flush\n\n # Cleanup\n csvfile.close() \n print('\\n (3) Buffer Drained - Data Saved to CSV File\\n')\n GPIO.cleanup()\n GPIO.setmode(GPIO.BCM)\n \n # Complete LED\n GPIO.setup(COMPLETE_LED, GPIO.OUT, initial=GPIO.LOW)\n GPIO.output(COMPLETE_LED,GPIO.HIGH)\n time.sleep(5)\n GPIO.cleanup()\n hat.a_in_scan_cleanup()\n global CMD_RECEIVED\n CMD_RECEIVED = 1\n \n # Restarts script to prepare for another recording\n main()","def generate_sample_sheet(self):\n pool = self.pool\n bcl2fastq_sample_ids = []\n i7_names = []\n i7_sequences = []\n i5_names = []\n i5_sequences = []\n wells = []\n plate = pool.container.external_id\n sample_ids = []\n sequencer_type = self.sequencer.equipment_type\n\n for component in pool.components:\n lp_composition = component['composition']\n # Get the well information\n wells.append(lp_composition.container.well_id)\n # Get the i7 index information\n i7_comp = lp_composition.i7_composition.primer_set_composition\n i7_names.append(i7_comp.external_id)\n i7_sequences.append(i7_comp.barcode)\n # Get the i5 index information\n i5_comp = lp_composition.i5_composition.primer_set_composition\n i5_names.append(i5_comp.external_id)\n i5_sequences.append(i5_comp.barcode)\n # Get the sample id\n sample_id = lp_composition.normalized_gdna_composition.\\\n gdna_composition.sample_composition.content\n sample_ids.append(sample_id)\n\n # Transform te sample ids to be bcl2fastq-compatible\n bcl2fastq_sample_ids = [\n SequencingProcess._bcl_scrub_name(sid) for sid in sample_ids]\n # Reverse the i5 sequences if needed based on the sequencer\n i5_sequences = SequencingProcess._sequencer_i5_index(\n sequencer_type, i5_sequences)\n\n data = SequencingProcess._format_sample_sheet_data(\n bcl2fastq_sample_ids, i7_names, i7_sequences, i5_names,\n i5_sequences, wells=wells, sample_plate=plate,\n description=sample_ids, sample_proj=self.run_name,\n lanes=self.lanes, sep=',')\n\n contacts = {c.name: c.email for c in self.contacts}\n pi = self.principal_investigator\n principal_investigator = {pi.name: pi.email}\n sample_sheet_dict = {\n 'comments': SequencingProcess._format_sample_sheet_comments(\n principal_investigator=principal_investigator,\n contacts=contacts),\n 'IEMFileVersion': '4',\n 'Investigator Name': pi.name,\n 'Experiment Name': self.experiment,\n 'Date': str(self.date),\n 'Workflow': 'GenerateFASTQ',\n 'Application': 'FASTQ Only',\n 'Assay': self.assay,\n 'Description': '',\n 'Chemistry': 'Default',\n 'read1': self.fwd_cycles,\n 'read2': self.rev_cycles,\n 'ReverseComplement': '0',\n 'data': data}\n return SequencingProcess._format_sample_sheet(sample_sheet_dict)","def hand_samples(data,lfs,rfs,start_frame,cap,show=False):\n data['lhkpss'] = hand.translate_hand_kps(data['lhkpss'],data['kpss'],7);\n data['rhkpss'] = hand.translate_hand_kps(data['rhkpss'],data['kpss'],4);\n row1 = [];\n row2 = [];\n for f in lfs:\n cap.set(cv2.CAP_PROP_POS_FRAMES,start_frame+f);\n _,frame = cap.read();\n data['crop'] = ut.crop(frame,256,320);\n data['i'] = f;\n row1.append(draw_lh_lines(data)[105:-65,105:-65]);\n for f in rfs:\n cap.set(cv2.CAP_PROP_POS_FRAMES,start_frame+f);\n _,frame = cap.read();\n data['crop'] = ut.crop(frame,256,320);\n data['i'] = f;\n row2.append(draw_rh_lines(data)[65:-105,65:-105]);\n row1 = np.concatenate(row1,axis=1);\n row2 = np.concatenate(row2,axis=1);\n grid = np.concatenate([row1,row2]);\n if show:\n ut.show(grid);\n return grid;","def samples_sorted():\n\n import glob\n cars_original = glob.glob(\"./vehicles/*/*.png\")\n # The following are duplicated:\n cars_KITTI = glob.glob(\"./vehicles/KITTI_extracted/*.png\")\n cars_GTI_Right = glob.glob(\"./vehicles/GTI_Right/*.png\")\n cars_GTI_Left = glob.glob(\"./vehicles/GTI_Left/*.png\")\n cars = cars_original + cars_KITTI + cars_GTI_Left + cars_GTI_Right\n # The above introduces duplication of samples, causing bleeding of training samples into validation\n np.random.shuffle(cars) # side effect return None\n cars_to_be_augmented = cars_GTI_Left + cars_GTI_Right\n np.random.shuffle(cars_to_be_augmented)\n num_cars = len(cars) + len(cars_to_be_augmented)\n\n non_cars_original = glob.glob(\"./non-vehicles/*/*.png\")\n # The following are duplicated:\n non_cars_Extras = glob.glob(\"./non-vehicles/Extras/*.png\")\n noncars = non_cars_original + non_cars_Extras + non_cars_Extras\n # The above introduces duplication of samples, causing bleeding of training samples into validation\n np.random.shuffle(noncars) # side effect return None\n num_noncars = len(noncars)\n return cars, noncars, cars_to_be_augmented, num_cars, num_noncars","def create_samples(self):\n for s_id in range(len(self.data[\"sample\"])):\n self.samples.add(Sample(s_id, [self.data[key][s_id] for key in self.data.keys() if key not in WRONG_KEYS],\n self.data[\"label\"][s_id]))","def sort_reads(self): \n if not self.sampling:\n self.convert_to_array()\n self.reads = self.reads[self.reads[:,0].argsort()]","def sample(self, size=1):\n pass","def __init__(self, starting_point=-1):\n self.i_read = starting_point\n self.data = [['fake_chip_id', 'fake_version'],\n [96, 110, 203, 104, 50, 0, 29, 145, 59, 215, 208, 11,\n 232, 38, 42, 255, 249, 255, 172, 38, 10, 216, 189, 16],\n [75],\n [129, 1, 0, 16, 44, 3, 30],\n [76, 60, 128, 129, 49, 128, 94, 120]]","def _init_sample(self):\n self.timestamps = np.zeros(5)\n self.data = np.zeros((5, 12))","def data_sample(CI, CC, thermal, calibration, health, driver_monitor, gps_location,\n poller, cal_status, cal_perc, overtemp, free_space, low_battery,\n driver_status, geofence, state, mismatch_counter, params):\n\n # Update carstate from CAN and create events\n CS = CI.update(CC)\n events = list(CS.events)\n enabled = isEnabled(state)\n\n # Receive from sockets\n td = None\n cal = None\n hh = None\n dm = None\n gps = None\n\n for socket, event in poller.poll(0):\n if socket is thermal:\n td = messaging.recv_one(socket)\n elif socket is calibration:\n cal = messaging.recv_one(socket)\n elif socket is health:\n hh = messaging.recv_one(socket)\n elif socket is driver_monitor:\n dm = messaging.recv_one(socket)\n elif socket is gps_location:\n gps = messaging.recv_one(socket)\n\n if td is not None:\n overtemp = td.thermal.thermalStatus >= ThermalStatus.red\n free_space = td.thermal.freeSpace < 0.15 # under 15% of space free no enable allowed\n low_battery = td.thermal.batteryPercent < 1 # at zero percent battery, OP should not be allowed\n\n # Create events for battery, temperature and disk space\n if low_battery:\n events.append(create_event('lowBattery', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\n if overtemp:\n events.append(create_event('overheat', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\n if free_space:\n events.append(create_event('outOfSpace', [ET.NO_ENTRY]))\n\n # Handle calibration\n if cal is not None:\n cal_status = cal.liveCalibration.calStatus\n cal_perc = cal.liveCalibration.calPerc\n\n if cal_status != Calibration.CALIBRATED:\n if cal_status == Calibration.UNCALIBRATED:\n events.append(create_event('calibrationIncomplete', [ET.NO_ENTRY, ET.SOFT_DISABLE, ET.PERMANENT]))\n else:\n events.append(create_event('calibrationInvalid', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\n\n # When the panda and controlsd do not agree on controls_allowed\n # we want to disengage openpilot. However the status from the panda goes through\n # another socket than the CAN messages, therefore one can arrive earlier than the other.\n # Therefore we allow a mismatch for two samples, then we trigger the disengagement.\n if not enabled:\n mismatch_counter = 0\n\n if hh is not None:\n controls_allowed = hh.health.controlsAllowed\n if not controls_allowed and enabled:\n mismatch_counter += 1\n if mismatch_counter >= 2:\n events.append(create_event('controlsMismatch', [ET.IMMEDIATE_DISABLE]))\n\n # Driver monitoring\n if dm is not None:\n driver_status.get_pose(dm.driverMonitoring, params)\n\n # Geofence\n if geofence is not None and gps is not None:\n geofence.update_geofence_status(gps.gpsLocationExternal, params)\n if geofence is not None and not geofence.in_geofence:\n events.append(create_event('geofence', [ET.NO_ENTRY, ET.WARNING]))\n\n return CS, events, cal_status, cal_perc, overtemp, free_space, low_battery, mismatch_counter","def _sample(self, rnn_output, temperature):\n pass","def process_sample(self, ch, method, properties, body):\n\n # data inside a dictionary\n # {'amplitude':[1.3,4.4,5...],\n # 'angle': [0.04,0.1,...]}\n sample_dict = self.deserialize_vtt_60_processed(body)\n\n with open('sample_test_run.txt', 'a') as f:\n x_arrstr = np.char.mod('%d', sample_dict['amplitude'])\n\n # x_arrstr -> should be 2d array \"frame\".\n raw_data = \",\".join(x_arrstr.flatten())\n f.write(raw_data)\n f.write('\\n')\n\n arr = np.array(sample_dict['amplitude'])\n\n frame = np.reshape(arr, (180,110))\n frame_transposed_flipped = np.flip(np.transpose(frame))\n frame_transposed_flipped = np.flip(np.transpose(frame))\n details_removed = frame_transposed_flipped\n details_removed = np.clip(frame_transposed_flipped, a_min=frame_transposed_flipped.max() - 15, a_max=None)\n self.i = self.i + 1\n if self.i % 10 == 0:\n b = sum(pd.DataFrame(frame).max().diff() / pd.DataFrame(frame).max() > 0.13)\n self.report_people(b)\n\n\n if body is None or sample_dict is None:\n print('Stream stopped.')\n return\n if self.samples_in_total % self.fps == 0:\n endTime = time.time()\n print('FPS: {:.1f}'.format(self.fps/(endTime - self.startTime)))\n self.startTime = endTime\n \n # your code here\n amplitude = sample_dict['amplitude']\n amplitude = np.reshape(amplitude,(180,110))\n amplitude = np.where(amplitude>130,130,amplitude)\n amplitude = np.uint8(255*amplitude/130)\n out = cv2.cvtColor(amplitude,cv2.COLOR_GRAY2BGR)\n out = cv2.applyColorMap(out,cv2.COLORMAP_MAGMA)\n cv2.imshow('junction',out)\n cv2.waitKey(10)","def collater(self, samples):\r\n raise NotImplementedError","def __init__(self, samples):\n self.samples = samples","def __init__(self):\n ChipData.ChipData.__init__(self)","def read_cine_protocol(series_dicom_header):\n assert len(series_dicom_header.StudyInstanceUID.unique()) == 1, 'Trying to read dicoms from multiple studies!'\n assert len(series_dicom_header.SpacingBetweenSlices.unique()) == 1\n\n SpacingBetweenSlices = list(series_dicom_header.SpacingBetweenSlices)[0]\n SliceLocations = series_dicom_header.SliceLocation.unique()\n number_of_slices = len(SliceLocations) \n\n phases_per_slice = [len(series_dicom_header[series_dicom_header.SliceLocation==SliceLocation].InstanceNumber) \n for SliceLocation in series_dicom_header.SliceLocation.unique()]\n number_of_phases = phases_per_slice[0]\n\n if len(np.unique(phases_per_slice)) != 1:\n warnings.warn('Number of phases is variable across slice locations! Could be real or error, check!.')\n return None\n \n print('Found cine study with (number_of_slices, number_of_phases)', number_of_slices, number_of_phases)\n pixel_array = pydicom.read_file(series_dicom_header.iloc[0].FileName).pixel_array\n \n sax_4D = np.zeros((pixel_array.shape +(number_of_slices, number_of_phases)), dtype=pixel_array.dtype)\n \n dicom_4D_paths = {}\n for SliceIndex, SliceLocation in enumerate(sorted(SliceLocations)):\n slice_header = series_dicom_header[series_dicom_header.SliceLocation==SliceLocation]\n dicom_4D_paths[SliceIndex] = []\n for InstanceIndex, InstanceNumber in enumerate(sorted(slice_header.InstanceNumber)):\n DicomFileName = slice_header[slice_header.InstanceNumber==InstanceNumber].FileName.item()\n dicom = pydicom.read_file(DicomFileName)\n sax_4D[:,:,SliceIndex,InstanceIndex] += dicom.pixel_array\n\n dicom_4D_paths[SliceIndex] += [DicomFileName]\n\n affine = read_affine(series_dicom_header.iloc[series_dicom_header.SliceLocation.argmin()])\n\n sax_4D = nib.Nifti1Image(sax_4D, affine=affine), \n sax_4D.SpacingBetweenSlices = SpacingBetweenSlices\n\n return sax_4D, dicom_4D_paths","def sample(self):\n logger.info(\"%s: collect sensor data\", self.__class__.__name__)\n samples = []\n self._fetch_data(samples)\n return samples","def __init__(self, array_size, readnoise, dark_current, gain):\n \n self.array_size = array_size\n self.readnoise = readnoise\n self.gain = gain\n self.dark_current = dark_current\n\n # Here are a bunch of default values setup.\n\n # Integration time in seconds\n self.itime = 1.0\n\n # Coadds\n self.coadds = 1\n\n # Fowler Samples for multi-CDS. This is the number of reads\n # in the beginning and repeated at the end.\n self.fowler = 1\n\n # Pixel Scale (arcsec / pixel)\n self.scale = 0.1 \n\n return","def collect(self):\n self.prev_position = {'lefthand':kinect.get_coord('lefthand'), \n 'righthand':kinect.get_coord('righthand')}\n \n while True:\n for hand in 'lefthand','righthand':\n position = kinect.get_coord(hand)\n displacement = vector.Subtract(position, self.prev_position[hand])\n acceleration = vector.Distance(displacement, self.prev_displacement[hand])\n self.prev_position[hand] = position\n self.prev_displacement[hand] = displacement\n # We square the acceleration so the variance is exaggerated\n self.accelerations[hand].append(acceleration**2) \n \n # Limit to latest self.sample_limit samples\n self.accelerations[hand] = self.accelerations[hand][-self.sample_limit:] \n self.velocities[hand].append(vector.Magnitude(displacement))\n self.velocities[hand] = self.velocities[hand][-self.sample_limit:]\n time.sleep(self.rate)","def _read_bu_wig(self, handle, sequence_name):\n self.chromosomes[sequence_name] = () \n for line in handle:\n position, total, reverse, forward = line.rstrip(\"\\r\\n\").split()\n self.coverage[(sequence_name, position)] = (int(reverse), int(forward))","def next_sample(self):\n if self.cur >= len(self.seq):\n raise StopIteration\n idx = self.seq[self.cur]\n self.cur += 1\n s = self.imgrec.read_idx(idx)\n header, img = recordio.unpack(s)\n img = mx.image.imdecode(img).asnumpy()\n hlabel = np.array(header.label).reshape( (self.num_classes,2) )\n if not config.label_xfirst:\n hlabel = hlabel[:,::-1] #convert to X/W first\n annot = {'scale': config.base_scale}\n\n #ul = np.array( (50000,50000), dtype=np.int32)\n #br = np.array( (0,0), dtype=np.int32)\n #for i in range(hlabel.shape[0]):\n # h = int(hlabel[i][0])\n # w = int(hlabel[i][1])\n # key = np.array((h,w))\n # ul = np.minimum(key, ul)\n # br = np.maximum(key, br)\n\n return img, hlabel, annot","def add_read(self, new_read): \n if self.sampling:\n self.convert_to_list()\n self.reads.append(new_read)\n self.total+=1","def rank_chanels():\r\n \r\n all_paths = [['data_bci\\\\row_data\\\\subject1\\\\'], ['data_bci\\\\row_data\\\\subject2\\\\'],['data_bci\\\\row_data\\\\subject3\\\\']]\r\n\r\n train_subjects = ['01']\r\n test_subject = '02'\r\n freq = 512\r\n\r\n cutoff_beggining = 0\r\n columns_to_read = ['Fp1', 'AF3' ,'F7', 'F3', 'FC1', 'FC5', 'T7', 'C3', 'CP1', 'CP5',\r\n 'P7', 'P3', 'Pz', 'PO3', 'O1', 'Oz', 'O2', 'PO4', 'P4', 'P8', 'CP6',\r\n 'CP2', 'C4', 'T8', 'FC6', 'FC2', 'F4', 'F8', 'AF4', 'Fp2', 'Fz', 'Cz','class']\r\n seq_len = 0\r\n cut_step = 0\r\n num_perseg = freq\r\n num_overlap = int(num_perseg/2)\r\n min_freq=8\r\n max_freq=45\r\n k = 3\r\n\r\n First_iter = True\r\n for path in all_paths:\r\n train_full_data, train_full_data_filtered, train_full_anots, test_full_data, test_sliced_full_filtered, test_full_annoations = read_filter(path, train_subjects,test_subject, columns_to_read, cutoff_beggining, seq_len, cut_step)\r\n\r\n psd_signals = eval_psd_not_modulated(train_full_data, num_perseg, num_overlap, freq, min_freq, max_freq) \r\n chanels_acc = iterate_over_chanels(psd_signals, train_full_anots, k)\r\n if First_iter:\r\n accuracy = chanels_acc\r\n First_iter = False\r\n else:\r\n accuracy += chanels_acc\r\n accuracy = accuracy/len(all_paths)\r\n sorted_indexies = np.argsort(accuracy)[::-1]\r\n\r\n\r\n #indexis_above_treshohld = [idx for idx in sorted_indexies if accuracy[idx]> min_accary]\r\n return sorted_indexies","def __call__(self, samples_number):\n self.sampler.sample(samples_number)","def Read_Encoders(self):\n max_diff = 100\n while max_diff > 1:\n max_diff = 0\n time.sleep(0.2)\n for i in range(3):\n last_read_pos = self.read_pos[i]\n value = self.fd_channel[i].read(3)+b'\\x00' \n # read the 24 bit register (3 bytes) and add a fourth byte \n # to make it an integer.\n signed_value = struct.unpack(\"=I\", value)[0] \n # Convert byte string to int\n if signed_value > 2**23:\n signed_value = signed_value - 2**24\n self.read_pos[i] = signed_value\n max_diff = max(max_diff, abs(last_read_pos - self.read_pos[i]))\n return","def __init__(self):\n self.ser = serial.Serial('/dev/ttyUSB3',9600)\n collect_readings = False\n self.colours = []\n self.max_readings = 50 #maximum number of readings to use","def test_sample(system_generator):\n\n name, test = system_generator()\n print(name)\n\n w_F, w_R, N_k = test.sample([10, 8], mode=\"wFwR\")\n w_F, w_R, N_k = test.sample([1, 1], mode=\"wFwR\")\n w_F, w_R, N_k = test.sample([10, 0], mode=\"wFwR\")\n w_F, w_R, N_k = test.sample([0, 5], mode=\"wFwR\")","def new_sample(self):\n\n self.u_seq.append([])\n self.r_exp.append(0)","def collect_samples(self):\n self.__running = True\n with open(self.__filename, 'a') as output:\n next_sample_time = time.time()\n while self.__running:\n sensor_name = self.__sensor.get_sensor_type_name()\n sensor_id = self.__sensor.get_sensor_id()\n data = self.__sensor.retrieve_data_string() \n if DEBUG:\n print('data: \"{}\"'.format(data),\n file = sys.stderr, flush=True)\n when = datetime.datetime.now(datetime.timezone.utc).isoformat()\n result = OUTPUT_FORMAT.format(when,\n sensor_name, \n sensor_id, \n data)\n output.write(result)\n output.flush()\n \n next_sample_time = next_sample_time + self.__interval\n delay_time = next_sample_time - time.time()\n if DEBUG:\n print('delay_time = {}'.format(delay_time),\n file=sys.stderr, flush=True)\n \n if 0 < delay_time: # don't sleep if already next sample time\n time.sleep(delay_time)","def _read(self):\n\t\tself._infoMuscles = []\n\t\tself._infoCommonCellsInMuscles = []\n\t\tself._infoSpecialCells = []\n\t\tself._infoCommonMuscleConnections = []\n\t\tself._infoInterMuscSensorimotorConnections = {}\n\t\tself._infoSpecialConnections = []\n\t\tif rank==0:\n\t\t\tsection = None\n\t\t\tsensorimotorConnections = None\n\t\t\tsensorimotorMatrix = None\n\t\t\tfor line in open(\"../nnStructures/\"+self._inputFile,\"r\"):\n\t\t\t\tif line[0] == \"#\" or line[0] == \"\\n\": continue\n\t\t\t\telif line[0] == \"@\": section = float(line[1])\n\t\t\t\telif section == 1: self._infoMuscles.append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 2: self._infoCommonCellsInMuscles.append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 3: self._infoSpecialCells.append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 4: self._infoCommonMuscleConnections.append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 5:\n\t\t\t\t\tif line[0] == \"+\":\n\t\t\t\t\t\tdictName = line[1:].strip(\"\\n\")\n\t\t\t\t\t\tself._infoInterMuscSensorimotorConnections[dictName] = {}\n\t\t\t\t\t\tsensorimotorConnections = False\n\t\t\t\t\t\tsensorimotorMatrix = False\n\t\t\t\t\telif \"Connections\" in line:\n\t\t\t\t\t\t sensorimotorConnections = True\n\t\t\t\t\t\t self._infoInterMuscSensorimotorConnections[dictName][\"connections\"]=[]\n\t\t\t\t\telif \"WeightsMatrix\" in line:\n\t\t\t\t\t\t sensorimotorConnections = False\n\t\t\t\t\t\t sensorimotorMatrix = True\n\t\t\t\t\t\t self._infoInterMuscSensorimotorConnections[dictName][\"matrix\"]=[]\n\t\t\t\t\telif sensorimotorConnections:\n\t\t\t\t\t\tself._infoInterMuscSensorimotorConnections[dictName][\"connections\"].append(line.strip(\"\\n\").split())\n\t\t\t\t\telif sensorimotorMatrix:\n\t\t\t\t\t\tself._infoInterMuscSensorimotorConnections[dictName][\"matrix\"].append(line.strip(\"\\n\").split())\n\t\t\t\telif section == 6: self._infoSpecialConnections.append(line.strip(\"\\n\").split())\n\n\t\tself._infoMuscles = comm.bcast(self._infoMuscles,root=0)\n\t\tself._infoCommonCellsInMuscles = comm.bcast(self._infoCommonCellsInMuscles,root=0)\n\t\tself._infoSpecialCells = comm.bcast(self._infoSpecialCells,root=0)\n\t\tself._infoCommonMuscleConnections = comm.bcast(self._infoCommonMuscleConnections,root=0)\n\t\tself._infoInterMuscSensorimotorConnections = comm.bcast(self._infoInterMuscSensorimotorConnections,root=0)\n\t\tself._infoSpecialConnections = comm.bcast(self._infoSpecialConnections,root=0)","def scan(self):\n for angle in range(self.MIDPOINT-350, self.MIDPOINT+350, 35):\n self.servo(angle)\n self.scan_data[angle] = self.read_distance()\n #sort the scan data for easier analysis\n self.scan_data = OrderedDict(sorted(self.scan_data.items()))","def fixture_sample_single() -> dict:\n _sample = {\n \"fastq\": \"<( zcat read_R1.fastq.gz )\",\n \"single_end\": True,\n \"sample_id\": \"single\",\n }\n return _sample","def sample(self):\n print(\"sampling bluetooth arduino\")\n self.sock.send(b'B')\n data = b''\n '''while True:\n data += self.sock.recv(1024)\n if data.endswith(b'\\n'):\n break\n '''\n #self.sock.settimeout(2)\n try:\n while True:\n d = self.sock.recv(255)\n data += d\n if d.find(b'\\n') != -1:\n break\n except Exception as err:\n print(err)\n pass\n print(data)\n data = json.loads(data.decode())\n if not any(x == 0 for x in data.values()):\n for label in self.data_labels:\n self.data[label].append(data[label])\n #self.data[\"time\"].append(time.time() - self.start)\n print(data)\n #print(self.data)\n #return self.data","def sample(self, detections):\n\n raise NotImplementedError","def sample_count(self):","def create_samples(self):\n self._samples = self.load_samples()\n self.modify_samples()","def _get_sample(self):\n return [layer._get_sample() for layer in self.layers]","def process_data(self, spec):\n with torch.no_grad():\n \n assert(len(spec) == 5), 'dataloader should return (spec_masked, pos_enc, mask_label, attn_mask, spec_stacked)'\n # Unpack and Hack bucket: Bucketing should cause acoustic feature to have shape 1xBxTxD'\n spec_masked = spec[0].squeeze(0)\n pos_enc = spec[1].squeeze(0)\n mask_label = spec[2].squeeze(0)\n attn_mask = spec[3].squeeze(0)\n spec_stacked = spec[4].squeeze(0)\n\n spec_masked = spec_masked.to(device=self.device)\n pos_enc = torch.FloatTensor(pos_enc).to(device=self.device)\n mask_label = torch.ByteTensor(mask_label).to(device=self.device)\n attn_mask = torch.FloatTensor(attn_mask).to(device=self.device)\n spec_stacked = spec_stacked.to(device=self.device)\n\n return spec_masked, pos_enc, mask_label, attn_mask, spec_stacked # (x, pos_enc, mask_label, attention_mask. y)","def create_read_list(samfile):\n read_sampler = ReadSampler()\n for line in samfile:\n line = sam_utils.SamAlignment(line)\n vals = line.get_aligned_blocks()\n if len(vals) > 1:\n logging.info(\"Skipping gapped read %s %s\"%(line.QNAME, str(vals))) \n read_sampler.add_read(vals[0])\n return read_sampler","def compileSection(self, j, section, hats):\n onebar = audio.AudioQuantumList()\n\n s1 = self.searchSamples(j, self.tonic)\n s2 = self.searchSamples(j, (self.tonic + 3) % 12)\n s3 = self.searchSamples(j, (self.tonic + 9) % 12)\n\n biggest = max([s1, s2, s3]) #for music that's barely tonal\n if not biggest:\n for i in xrange(0, 12):\n biggest = self.searchSamples(j, self.tonic + i)\n if biggest:\n break\n\n if not biggest:\n raise Exception('Missing samples in section %s of the song!' % j+1)\n\n if not s1: s1 = biggest\n if not s2: s2 = biggest\n if not s3: s3 = biggest\n\n if self.template['target'] == \"tatums\":\n f = 4\n r = 2\n elif self.template['target'] == \"beats\":\n f = 2\n r = 2\n elif self.template['target'] == \"bars\":\n f = 1\n r = 1\n for k in xrange(0, r):\n for i in xrange(0, 4*f):\n onebar.append(s1[i % len(s1)])\n for i in xrange(4*f, 6*f):\n onebar.append( s2[i % len(s2)] )\n for i in xrange(6*f, 8*f):\n onebar.append( s3[i % len(s3)] )\n if self.original.analysis.time_signature == 4:\n orig_bar = self.st.shiftTempo(audio.getpieces(self.original, onebar), self.template['tempo']/self.tempo)\n else:\n orig_bar = audio.getpieces(self.original, onebar)\n orig_bar = self.st.shiftTempo(orig_bar, len(orig_bar) / ((44100 * 16 * 2 * 60.0)/self.template['tempo']))\n if orig_bar.numChannels == 1:\n orig_bar = self.mono_to_stereo(orig_bar)\n mixfactor = self.mixfactor(onebar)\n a = self.truncatemix(\n audio.mix(\n audio.AudioData(\n self.sample_path + self.template['wubs'][self.tonic], \n sampleRate=44100,\n numChannels=2,\n verbose=False\n ),\n audio.AudioData(\n self.sample_path + self.template['splashes'][(j+1) % len(self.template['splashes'])],\n sampleRate=44100,\n numChannels=2,\n verbose=False\n )\n ),\n orig_bar,\n mixfactor\n )\n b = self.truncatemix(\n audio.mix(\n audio.AudioData(\n self.sample_path + self.template['wub_breaks'][self.tonic],\n sampleRate=44100,\n numChannels=2,\n verbose=False\n ),\n hats\n ),\n orig_bar,\n mixfactor\n )\n return (a, b)","def __init__(self, parent):\n \n #60 32 bit integers are recorded for the amplifier sample time index \n self.sample_time_index = []\n for i in range(60):\n sample_time = np.int32(struct.unpack('i', parent.rhd.read(4)))[0]\n self.sample_time_index.append(sample_time)\n\n #Amplifier voltages for each channel\n self.electrode_traces = {}#key: channel name value: voltage trce\n for amp in parent._AMPLIFIER_CHANNELS:\n electrode_voltage_trace = []\n #60 samples per channel, int16\n for i in range(60):\n electrode_voltage = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\n electrode_voltage_trace.append(electrode_voltage)\n self.electrode_traces[amp] = electrode_voltage_trace \n\n #Get voltage from Aux input channels\n self.auxilary_traces = {}\n for aux in parent._AUX_CHANNELS:\n aux_voltage_trace = []\n #15 samples per channel, int16\n for i in range(15):\n aux_voltage = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\n aux_voltage_trace.append(aux_voltage)\n self.auxilary_traces[aux] = aux_voltage_trace \n\n #get voltage from supply voltage channels\n self.supply_voltages = {}\n for sup in parent._SUPPLY_VOLTAGE_CHANNELS:\n sup_voltage_list = []\n for i in range(1):\n sup_voltage = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\n sup_voltage_list.append(sup_voltage)\n self.supply_voltages[sup] = sup_voltage_list \n\n #get voltage from temerature sensor channels\n self.temerature_sensor_readings = {}\n for n in range(parent._TEMP_SENSORS):\n temp_list = []\n for i in range(1):\n temperature = np.int16(struct.unpack('h', parent.rhd.read(2)))[0]\n temp_list.append(temperature)\n self.temerature_sensor_readings[n] = temp_list \n\n #Get voltage ADC inputs\n self.board_adc_input_voltages = {}\n for adc in parent._ADC_INPUT_CHANNELS:\n adc_input_list = []\n for i in range(60):\n adc_input = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\n adc_input_list.append(adc_input)\n self.board_adc_input_voltages[adc] = adc_input_list \n\n #Get digital input values\n self.board_digital_inputs = {}\n for dig in parent._DIGITAL_INPUT_CHANNELS :\n digital_input_list = []\n for i in range(60):\n digital_input = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\n digital_input_list.append(digital_input)\n self.board_digital_inputs[dig.native_channel_name] = digital_input_list","def sample_room(config):\n room = np.zeros((3,))\n room[0] = get_sample(config['length'], n_sample=1)[0]\n room[1] = get_sample(config['width'], n_sample=1)[0]\n room[2] = get_sample(config['height'], n_sample=1)[0]\n return room","def get_disk_rw(sampling_duration):\n \n #get te list of devices\n with open('/proc/partitions') as f:\n devices = [re.search('\\s([^\\s]+)$', line).group(1).strip() for line in re.findall('^\\s*[0-9]+\\s+[1-9]+.*$', f.read(), flags = re.MULTILINE)]\n \n with open('/proc/diskstats') as f1:\n with open('/proc/diskstats') as f2:\n content1 = f1.read() #first collection\n yield {} #yield so that caller can put delay before sampling again\n content2 = f2.read() #second collection\n \n #initialize the dict with interfaces and values\n data = dict(zip(devices, [dict(zip(['reads', 'writes'], [0, 0])) for device in devices]))\n\n for line in content1.splitlines(): #read through first collection\n for device in [device_x for device_x in devices if '%s ' % device_x in line]:\n fields = line.strip().split('%s ' % device)[1].split()\n data[device]['reads'] = int(fields[0])\n data[device]['writes'] = int(fields[4])\n break\n \n for line in content2.splitlines(): #read through second collection\n for device in [device_x for device_x in devices if '%s ' % device_x in line]:\n fields = line.strip().split('%s ' % device)[1].split()\n data[device]['reads'] = (int(fields[0]) - data[device]['reads']) / float(sampling_duration)\n data[device]['writes'] = (int(fields[4]) - data[device]['writes']) / float(sampling_duration)\n break \n \n yield data","def dataset_prepare_CWRU(self, sample_num, sample_len):\r\n\r\n logging.info(\"generating new dataset with each case has (sample_num = %d, sample_len = %d)\"\r\n % (sample_num, sample_len))\r\n\r\n signals, filelabels_wc, filelabels_fs = self.data_clean_CWRU()\r\n data, labels_wc, labels_fs = [], [], []\r\n for k, signal in enumerate(signals):\r\n data.append(ut.signal_split_as_samples(signal, sample_len, sample_num))\r\n sample_labels_wc = np.ones((sample_num, 1)) * filelabels_wc[k]\r\n sample_labels_wc = ut.onehot_encoding(sample_labels_wc, class_num=10)\r\n labels_wc.append(sample_labels_wc)\r\n\r\n sample_labels_fs = np.ones((sample_num, 1)) * filelabels_fs[k]\r\n sample_labels_fs = ut.onehot_encoding(sample_labels_fs, class_num=4)\r\n labels_fs.append(sample_labels_fs)\r\n\r\n for i in range(2):\r\n for signal in signals[-4:]:\r\n data.append(ut.signal_split_as_samples(signal, sample_len, sample_num))\r\n sample_labels_wc = np.zeros((sample_num, 1))\r\n sample_labels_wc = ut.onehot_encoding(sample_labels_wc, class_num=10)\r\n labels_wc.append(sample_labels_wc)\r\n\r\n sample_labels_fs = np.zeros((sample_num, 1))\r\n sample_labels_fs = ut.onehot_encoding(sample_labels_fs, class_num=4)\r\n labels_fs.append(sample_labels_fs)\r\n\r\n data, labels_wc, labels_fs = np.array(data), np.array(labels_wc), np.array(labels_fs)\r\n os.chdir(self.path_cache)\r\n np.savez(\"CWRU_1D_signal.npz\", data=data, labels_wc=labels_wc, labels_fs=labels_fs)\r\n os.chdir(self.path)\r\n\r\n logging.info(\"new dataset has been stored\")\r\n\r\n return 0","def setup(self):\n # get unsorted vs sorted units\n data_dict = mat73.loadmat(self.file)\n units_unsorted = []\n units_sorted = []\n for ch_curr in data_dict['spikes']:\n units_unsorted.append(ch_curr[0]) # from data description, first unit is unsorted\n for unit_curr in ch_curr[1:]:\n if unit_curr is not None:\n units_sorted.append(unit_curr)\n \n # getting binned spikes\n bin_size_ms = 10\n # window for binning\n mintime, maxtime = 100, 0\n for spk_times_curr in units_sorted:\n mintime = min(spk_times_curr[0], mintime)\n maxtime = max(spk_times_curr[-1], maxtime)\n # get binned spikes\n spk_bins = np.arange(mintime, maxtime, bin_size_ms/1000)\n spks_binned = []\n for i, unit_curr in enumerate(units_sorted):\n spks_binned_curr, _ = np.histogram(unit_curr, bins=spk_bins, range=(spk_bins[0], spk_bins[-1]))\n spks_binned.append(spks_binned_curr)\n self.data = np.array(spks_binned).T\n\n self.l = 1 # columns per update\n l1 = 100 # columns used to initialize\n self.t = l1\n self.num_iters = np.floor((self.data.shape[0] - l1 - self.l)/self.l).astype('int')\n\n #send to dim reduction\n init_id = self.client.put([self.data.shape[0], self.data[:l1, :]], \"init_data\")\n logger.info(\"Putted init data\")\n self.q_out.put(init_id)","def samples(self, gp):\r\n raise NotImplementedError","def create(self):\n\n for sample_name, sample_info in self.samples.items():\n if not sample_info[\"use_it\"]:\n continue\n process_name = sample_info[\"process_name_specific\"]\n sample_category = sample_info[\"sample_category\"]\n is_mc = (sample_info[\"type\"] == \"mc\")\n\n logging.info(\"Building dictionaries for sample %s...\" % process_name)\n for charge_selection in self.charge_selections:\n central_or_shift_extensions = [\"\", \"hadd\", \"addBackgrounds\"]\n central_or_shifts_extended = central_or_shift_extensions + self.central_or_shifts\n for central_or_shift_or_dummy in central_or_shifts_extended:\n process_name_extended = [ process_name, \"hadd\" ]\n for process_name_or_dummy in process_name_extended:\n if central_or_shift_or_dummy in [ \"hadd\" ] and process_name_or_dummy in [ \"hadd\" ]:\n continue\n if central_or_shift_or_dummy != \"central\" and central_or_shift_or_dummy not in central_or_shift_extensions:\n if not is_mc:\n continue\n if not self.accept_central_or_shift(central_or_shift_or_dummy, sample_info):\n continue\n\n key_dir = getKey(process_name_or_dummy, charge_selection, central_or_shift_or_dummy)\n for dir_type in [ DKEY_CFGS, DKEY_HIST, DKEY_LOGS, DKEY_RLES ]:\n initDict(self.dirs, [ key_dir, dir_type ])\n if dir_type in [ DKEY_CFGS, DKEY_LOGS ]:\n self.dirs[key_dir][dir_type] = os.path.join(self.get_dir_type(dir_type), dir_type, self.channel,\n \"_\".join([ charge_selection ]), process_name_or_dummy, central_or_shift_or_dummy)\n else:\n self.dirs[key_dir][dir_type] = os.path.join(self.outputDir, dir_type, self.channel,\n \"_\".join([ charge_selection ]), process_name_or_dummy)\n for subdirectory in [ \"comp_jetToTauFakeRate\", \"makePlots\" ]:\n key_dir = getKey(subdirectory)\n for dir_type in [ DKEY_CFGS, DKEY_HIST, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT ]:\n initDict(self.dirs, [ key_dir, dir_type ])\n if dir_type in [ DKEY_CFGS, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT ]:\n self.dirs[key_dir][dir_type] = os.path.join(self.get_dir_type(dir_type), dir_type, self.channel, subdirectory)\n else:\n self.dirs[key_dir][dir_type] = os.path.join(self.outputDir, dir_type, self.channel, subdirectory)\n for dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_HIST, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\n initDict(self.dirs, [ dir_type ])\n if dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\n self.dirs[dir_type] = os.path.join(self.get_dir_type(dir_type), dir_type, self.channel)\n else:\n self.dirs[dir_type] = os.path.join(self.outputDir, dir_type, self.channel)\n\n numDirectories = 0\n for key in self.dirs.keys():\n if type(self.dirs[key]) == dict:\n numDirectories += len(self.dirs[key])\n else:\n numDirectories += 1\n logging.info(\"Creating directory structure (numDirectories = %i)\" % numDirectories)\n numDirectories_created = 0;\n frac = 1\n for key in self.dirs.keys():\n if type(self.dirs[key]) == dict:\n for dir_type in self.dirs[key].keys():\n create_if_not_exists(self.dirs[key][dir_type])\n numDirectories_created += len(self.dirs[key])\n else:\n create_if_not_exists(self.dirs[key])\n numDirectories_created = numDirectories_created + 1\n while 100*numDirectories_created >= frac*numDirectories:\n logging.info(\" %i%% completed\" % frac)\n frac = frac + 1\n logging.info(\"Done.\")\n\n inputFileLists = {}\n for sample_name, sample_info in self.samples.items():\n if not sample_info[\"use_it\"]:\n continue\n logging.info(\"Checking input files for sample %s\" % sample_info[\"process_name_specific\"])\n inputFileLists[sample_name] = generateInputFileList(sample_info, self.max_files_per_job)\n\n self.inputFileIds = {}\n for sample_name, sample_info in self.samples.items():\n if not sample_info[\"use_it\"]:\n continue\n\n process_name = sample_info[\"process_name_specific\"]\n inputFileList = inputFileLists[sample_name]\n\n logging.info(\"Creating configuration files to run '%s' for sample %s\" % (self.executable_analyze, process_name))\n\n is_mc = (sample_info[\"type\"] == \"mc\")\n sample_category = sample_info[\"sample_category\"]\n\n for charge_selection in self.charge_selections:\n for central_or_shift in self.central_or_shifts:\n \n if central_or_shift != \"central\" and not is_mc:\n continue\n if not self.accept_central_or_shift(central_or_shift, sample_info):\n continue\n\n # build config files for executing analysis code\n key_analyze_dir = getKey(process_name, charge_selection, central_or_shift)\n\n for jobId in inputFileList.keys():\n\n analyze_job_tuple = (process_name, charge_selection, central_or_shift, jobId)\n key_analyze_job = getKey(*analyze_job_tuple)\n ntupleFiles = inputFileList[jobId]\n if len(ntupleFiles) == 0:\n logging.warning(\"No input ntuples for %s --> skipping job !!\" % (key_analyze_job))\n continue\n\n cfgFile_modified_path = os.path.join(self.dirs[key_analyze_dir][DKEY_CFGS], \"analyze_%s_%s_%s_%i_cfg.py\" % analyze_job_tuple)\n logFile_path = os.path.join(self.dirs[key_analyze_dir][DKEY_LOGS], \"analyze_%s_%s_%s_%i.log\" % analyze_job_tuple)\n histogramFile_path = os.path.join(self.dirs[key_analyze_dir][DKEY_HIST], \"analyze_%s_%s_%s_%i.root\" % analyze_job_tuple)\n rleOutputFile_path = os.path.join(self.dirs[key_analyze_dir][DKEY_RLES], \"rle_%s_%s_%s_%i.txt\" % analyze_job_tuple) \\\n if self.select_rle_output else \"\"\n\n self.jobOptions_analyze[key_analyze_job] = {\n 'ntupleFiles' : ntupleFiles,\n 'cfgFile_modified' : cfgFile_modified_path,\n 'histogramFile' : histogramFile_path,\n 'logFile' : logFile_path,\n 'chargeSelection' : charge_selection,\n 'jet_minPt' : self.jet_minPt,\n 'jet_maxPt' : self.jet_maxPt,\n 'jet_minAbsEta' : self.jet_minAbsEta,\n 'jet_maxAbsEta' : self.jet_maxAbsEta,\n 'hadTau_selection_tight' : self.hadTau_selection_tight,\n 'hadTauSelection_denominator' : self.hadTau_selection_denominator,\n 'hadTauSelections_numerator' : self.hadTau_selections_numerator,\n 'trigMatchingOptions' : self.trigMatchingOptions,\n 'selEventsFileName_output' : rleOutputFile_path,\n 'absEtaBins' : self.absEtaBins,\n 'decayModes' : self.decayModes,\n 'central_or_shift' : central_or_shift,\n 'central_or_shifts_local' : [],\n 'apply_hlt_filter' : self.hlt_filter,\n }\n self.createCfg_analyze(self.jobOptions_analyze[key_analyze_job], sample_info)\n\n # initialize input and output file names for hadd_stage1\n key_hadd_stage1_dir = getKey(process_name, charge_selection)\n hadd_stage1_job_tuple = (process_name, charge_selection)\n key_hadd_stage1_job = getKey(*hadd_stage1_job_tuple)\n if not key_hadd_stage1_job in self.inputFiles_hadd_stage1:\n self.inputFiles_hadd_stage1[key_hadd_stage1_job] = []\n self.inputFiles_hadd_stage1[key_hadd_stage1_job].append(self.jobOptions_analyze[key_analyze_job]['histogramFile'])\n self.outputFile_hadd_stage1[key_hadd_stage1_job] = os.path.join(self.dirs[key_hadd_stage1_dir][DKEY_HIST],\n \"hadd_stage1_%s_%s.root\" % hadd_stage1_job_tuple)\n\n # initialize input and output file names for hadd_stage2\n key_hadd_stage1_job = getKey(process_name, charge_selection)\n key_hadd_stage2_dir = getKey(\"hadd\", charge_selection)\n key_hadd_stage2_job = getKey(charge_selection)\n if not key_hadd_stage2_job in self.inputFiles_hadd_stage2:\n self.inputFiles_hadd_stage2[key_hadd_stage2_job] = []\n self.inputFiles_hadd_stage2[key_hadd_stage2_job].append(self.outputFile_hadd_stage1[key_hadd_stage1_job])\n self.outputFile_hadd_stage2[key_hadd_stage2_job] = os.path.join(self.dirs[key_hadd_stage2_dir][DKEY_HIST],\n \"hadd_stage2_%s.root\" % charge_selection)\n\n logging.info(\"Creating configuration files for executing 'comp_jetToTauFakeRate'\")\n for charge_selection in self.charge_selections:\n charge_key = \"comp_%s\" % charge_selection\n self.comp_input_files[charge_key] = []\n for trigMatchingOption in self.trigMatchingOptions:\n key_hadd_stage2_job = getKey(charge_selection)\n key_comp_jetToTauFakeRate_dir = getKey(\"comp_jetToTauFakeRate\")\n key_comp_jetToTauFakeRate_job = getKey(charge_selection, trigMatchingOption)\n self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job] = {\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2_job],\n 'cfgFile_modified' : os.path.join(\n self.dirs[DKEY_CFGS], \"comp_jetToTauFakeRate_%s_%s_cfg.py\" % (charge_selection, trigMatchingOption)),\n 'outputFile' : os.path.join(\n self.dirs[DKEY_HIST], \"comp_jetToTauFakeRate_%s_%s.root\" % (charge_selection, trigMatchingOption)),\n 'logFile' : os.path.join(\n self.dirs[DKEY_LOGS], \"comp_jetToTauFakeRate_%s_%s.log\" % (charge_selection, trigMatchingOption)),\n 'looseRegion' : \"jetToTauFakeRate_%s_%s/denominator/\" % (charge_selection, trigMatchingOption),\n 'tightRegion' : \"jetToTauFakeRate_%s_%s/numerator/\" % (charge_selection, trigMatchingOption),\n 'absEtaBins' : self.absEtaBins,\n 'ptBins' : self.ptBins,\n 'decayModes' : self.decayModes,\n 'hadTauSelections' : self.hadTau_selections_numerator,\n 'trigMatchingOption' : trigMatchingOption,\n 'plots_outputFileName' : os.path.join(self.dirs[key_comp_jetToTauFakeRate_dir][DKEY_PLOT], \"comp_jetToTauFakeRate_%s.png\" % trigMatchingOption)\n }\n self.createCfg_comp_jetToTauFakeRate(self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job])\n comp_output = self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job]['outputFile']\n self.targets.append(comp_output)\n self.comp_input_files[charge_key].append(comp_output)\n self.comp_output_files[charge_key] = os.path.join(self.dirs[DKEY_HIST], \"comp_jetToTauFakeRate_%s.root\" % charge_selection)\n\n logging.info(\"Creating configuration files to run 'makePlots'\")\n for charge_selection in self.charge_selections:\n key_hadd_stage2_job = getKey(charge_selection)\n key_makePlots_dir = getKey(\"makePlots\")\n key_makePlots_job = getKey(charge_selection) \n self.jobOptions_make_plots[key_makePlots_job] = {\n 'executable' : self.executable_make_plots,\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2_job],\n 'cfgFile_modified' : os.path.join(\n self.dirs[key_makePlots_dir][DKEY_CFGS], \"makePlots_%s_cfg.py\" % self.channel),\n 'outputFile' : os.path.join(\n self.dirs[key_makePlots_dir][DKEY_PLOT], \"makePlots_%s.png\" % self.channel),\n 'histogramDir' : \"jetToTauFakeRate_%s\" % charge_selection,\n 'label' : None,\n 'make_plots_backgrounds' : self.make_plots_backgrounds\n }\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\n for trigMatchingOption in self.trigMatchingOptions:\n self.cfgFile_make_plots = self.cfgFile_make_plots_denominator\n for absEtaBin in [ \"absEtaLt1_5\", \"absEta1_5to9_9\" ]:\n key_hadd_stage2_job = getKey(charge_selection)\n key_makePlots_job = getKey(charge_selection, trigMatchingOption, absEtaBin, \"denominator\") \n self.jobOptions_make_plots[key_makePlots_job] = {\n 'executable' : self.executable_make_plots,\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2_job],\n 'cfgFile_modified' : os.path.join(\n self.dirs[key_makePlots_dir][DKEY_CFGS], \"makePlots_%s_%s_%s_denominator_%s_cfg.py\" % \\\n (self.channel, charge_selection, trigMatchingOption, absEtaBin)),\n 'outputFile' : os.path.join(\n self.dirs[key_makePlots_dir][DKEY_PLOT], \"makePlots_%s_%s_%s_denominator_%s.png\" % (self.channel, charge_selection, trigMatchingOption, absEtaBin)),\n 'histogramDir' : \"jetToTauFakeRate_%s_%s/denominator/%s\" % (charge_selection, trigMatchingOption, absEtaBin),\n 'label' : None,\n 'make_plots_backgrounds' : self.make_plots_backgrounds\n }\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\n for hadTau_selection_numerator in self.hadTau_selections_numerator:\n key_hadd_stage2_job = getKey(charge_selection)\n key_makePlots_job = getKey(charge_selection, trigMatchingOption, absEtaBin, \"numerator\", hadTau_selection_numerator)\n self.jobOptions_make_plots[key_makePlots_job] = {\n 'executable' : self.executable_make_plots,\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2_job],\n 'cfgFile_modified' : os.path.join(\n self.dirs[key_makePlots_dir][DKEY_CFGS], \"makePlots_%s_%s_%s_numerator_%s_%s_cfg.py\" % \\\n (self.channel, charge_selection, trigMatchingOption, hadTau_selection_numerator, absEtaBin)),\n 'outputFile' : os.path.join(\n self.dirs[key_makePlots_dir][DKEY_PLOT], \"makePlots_%s_%s_%s_numerator_%s_%s.png\" % \\\n (self.channel, charge_selection, trigMatchingOption, hadTau_selection_numerator, absEtaBin)),\n 'histogramDir' : \"jetToTauFakeRate_%s_%s/numerator/%s/%s\" % (charge_selection, trigMatchingOption, hadTau_selection_numerator, absEtaBin),\n 'label' : None,\n 'make_plots_backgrounds' : self.make_plots_backgrounds\n }\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\n\n self.sbatchFile_analyze = os.path.join(self.dirs[DKEY_SCRIPTS], \"sbatch_analyze_%s.py\" % self.channel)\n self.sbatchFile_comp_jetToTauFakeRate = os.path.join(self.dirs[DKEY_SCRIPTS], \"sbatch_comp_jetToTauFakeRate.py\")\n if self.is_sbatch:\n logging.info(\"Creating script for submitting '%s' jobs to batch system\" % self.executable_analyze)\n self.createScript_sbatch_analyze(self.executable_analyze, self.sbatchFile_analyze, self.jobOptions_analyze)\n logging.info(\"Creating script for submitting '%s' jobs to batch system\" % self.executable_comp_jetToTauFakeRate)\n self.createScript_sbatch(self.executable_comp_jetToTauFakeRate, self.sbatchFile_comp_jetToTauFakeRate, self.jobOptions_comp_jetToTauFakeRate)\n\n lines_makefile = []\n self.addToMakefile_analyze(lines_makefile)\n self.addToMakefile_hadd_stage1(lines_makefile)\n self.addToMakefile_hadd_stage2(lines_makefile, make_dependency = \"phony_hadd_stage1\", max_mem = '4096M')\n self.addToMakefile_comp_jetToTauFakeRate(lines_makefile)\n self.addToMakefile_comp_hadd(lines_makefile)\n self.addToMakefile_make_plots(lines_makefile)\n self.createMakefile(lines_makefile)\n\n logging.info(\"Done.\")\n\n return self.num_jobs","def scan(self):\n for angle in range(self.MIDPOINT-400, self.MIDPOINT+401, 100):\n self.servo(angle)\n self.scan_data[angle] = self.read_distance()\n #sort the scan data for easier analysis\n self.scan_data = OrderedDict(sorted(self.scan_data.items()))","def rebuild(self):\n self.from_samples(self.samples)","def _sample_single(self):\n ss = super(SuperResolutions, self)._sample_single()\n image = ss['data']\n # Down sample\n max_down_sample = max(self.data_down_sample, self.label_down_sample)\n if self.is_down_sample:\n images = []\n images.append(image)\n for i in range(max_down_sample):\n image = self.downsample(image)\n images.append(image)\n data = images[self.data_down_sample]\n label = images[self.label_down_sample]\n return {'data': data, 'label': label}","def test_irr_random_chread(irregular_written_data):\n\n fetches = 20\n channels = [1,3]\n starts = np.random.randint(0, 5e4, fetches)\n stops = starts + np.random.randint(0, 1e6)\n\n fp, written = irregular_written_data\n with openEDF(fp) as reader:\n reader.channels = channels\n for start, stop in zip(starts, stops):\n arr = reader.read(start, stop, padvalue=np.NaN)\n x = written[channels, start:stop]\n #imprecision due to 2-byte conversion so tolerance set to 1 unit\n assert np.allclose(arr, x, equal_nan=True, atol=1)","def read_data(filename):\n from intanutil.read_header import read_header\n from intanutil.get_bytes_per_data_block import get_bytes_per_data_block\n from intanutil.read_one_data_block import read_one_data_block\n from intanutil.notch_filter import notch_filter\n from intanutil.data_to_result import data_to_result \n \n\n tic = time.time()\n fid = open(filename, 'rb')\n filesize = os.path.getsize(filename)\n\n header = read_header(fid)\n\n print('Found {} amplifier channel{}.'.format(header['num_amplifier_channels'], plural(header['num_amplifier_channels'])))\n print('Found {} auxiliary input channel{}.'.format(header['num_aux_input_channels'], plural(header['num_aux_input_channels'])))\n print('Found {} supply voltage channel{}.'.format(header['num_supply_voltage_channels'], plural(header['num_supply_voltage_channels'])))\n print('Found {} board ADC channel{}.'.format(header['num_board_adc_channels'], plural(header['num_board_adc_channels'])))\n print('Found {} board digital input channel{}.'.format(header['num_board_dig_in_channels'], plural(header['num_board_dig_in_channels'])))\n print('Found {} board digital output channel{}.'.format(header['num_board_dig_out_channels'], plural(header['num_board_dig_out_channels'])))\n print('Found {} temperature sensors channel{}.'.format(header['num_temp_sensor_channels'], plural(header['num_temp_sensor_channels'])))\n print('')\n\n # Determine how many samples the data file contains.\n bytes_per_block = get_bytes_per_data_block(header)\n\n # How many data blocks remain in this file?\n data_present = False\n bytes_remaining = filesize - fid.tell()\n if bytes_remaining > 0:\n data_present = True\n\n if bytes_remaining % bytes_per_block != 0:\n raise Exception('Something is wrong with file size : should have a whole number of data blocks')\n\n num_data_blocks = int(bytes_remaining / bytes_per_block)\n\n num_amplifier_samples = header['num_samples_per_data_block'] * num_data_blocks\n num_aux_input_samples = int((header['num_samples_per_data_block'] / 4) * num_data_blocks)\n num_supply_voltage_samples = 1 * num_data_blocks\n num_board_adc_samples = header['num_samples_per_data_block'] * num_data_blocks\n num_board_dig_in_samples = header['num_samples_per_data_block'] * num_data_blocks\n num_board_dig_out_samples = header['num_samples_per_data_block'] * num_data_blocks\n\n record_time = num_amplifier_samples / header['sample_rate']\n\n if data_present:\n print('File contains {:0.3f} seconds of data. Amplifiers were sampled at {:0.2f} kS/s.'.format(record_time, header['sample_rate'] / 1000))\n else:\n print('Header file contains no data. Amplifiers were sampled at {:0.2f} kS/s.'.format(header['sample_rate'] / 1000))\n\n if data_present:\n # Pre-allocate memory for data.\n print('')\n print('Allocating memory for data...')\n\n data = {}\n if (header['version']['major'] == 1 and header['version']['minor'] >= 2) or (header['version']['major'] > 1):\n data['t_amplifier'] = np.zeros(num_amplifier_samples, dtype=np.int_)\n else:\n data['t_amplifier'] = np.zeros(num_amplifier_samples, dtype=np.uint)\n\n data['amplifier_data'] = np.zeros([header['num_amplifier_channels'], num_amplifier_samples], dtype=np.uint)\n data['aux_input_data'] = np.zeros([header['num_aux_input_channels'], num_aux_input_samples], dtype=np.uint)\n data['supply_voltage_data'] = np.zeros([header['num_supply_voltage_channels'], num_supply_voltage_samples], dtype=np.uint)\n data['temp_sensor_data'] = np.zeros([header['num_temp_sensor_channels'], num_supply_voltage_samples], dtype=np.uint)\n data['board_adc_data'] = np.zeros([header['num_board_adc_channels'], num_board_adc_samples], dtype=np.uint)\n \n # by default, this script interprets digital events (digital inputs and outputs) as booleans\n # if unsigned int values are preferred(0 for False, 1 for True), replace the 'dtype=np.bool_' argument with 'dtype=np.uint' as shown\n # the commented line below illustrates this for digital input data; the same can be done for digital out\n \n #data['board_dig_in_data'] = np.zeros([header['num_board_dig_in_channels'], num_board_dig_in_samples], dtype=np.uint)\n data['board_dig_in_data'] = np.zeros([header['num_board_dig_in_channels'], num_board_dig_in_samples], dtype=np.bool_)\n data['board_dig_in_raw'] = np.zeros(num_board_dig_in_samples, dtype=np.uint)\n \n data['board_dig_out_data'] = np.zeros([header['num_board_dig_out_channels'], num_board_dig_out_samples], dtype=np.bool_)\n data['board_dig_out_raw'] = np.zeros(num_board_dig_out_samples, dtype=np.uint)\n\n # Read sampled data from file.\n print('Reading data from file...')\n\n # Initialize indices used in looping\n indices = {}\n indices['amplifier'] = 0\n indices['aux_input'] = 0\n indices['supply_voltage'] = 0\n indices['board_adc'] = 0\n indices['board_dig_in'] = 0\n indices['board_dig_out'] = 0\n\n print_increment = 10\n percent_done = print_increment\n for i in range(num_data_blocks):\n read_one_data_block(data, header, indices, fid)\n\n # Increment indices\n indices['amplifier'] += header['num_samples_per_data_block']\n indices['aux_input'] += int(header['num_samples_per_data_block'] / 4)\n indices['supply_voltage'] += 1\n indices['board_adc'] += header['num_samples_per_data_block']\n indices['board_dig_in'] += header['num_samples_per_data_block']\n indices['board_dig_out'] += header['num_samples_per_data_block'] \n\n fraction_done = 100 * (1.0 * i / num_data_blocks)\n if fraction_done >= percent_done:\n print('{}% done...'.format(percent_done))\n percent_done = percent_done + print_increment\n\n # Make sure we have read exactly the right amount of data.\n bytes_remaining = filesize - fid.tell()\n if bytes_remaining != 0: raise Exception('Error: End of file not reached.')\n\n\n\n # Close data file.\n fid.close()\n\n if (data_present):\n print('Parsing data...')\n\n # Extract digital input channels to separate variables.\n for i in range(header['num_board_dig_in_channels']):\n data['board_dig_in_data'][i, :] = np.not_equal(np.bitwise_and(data['board_dig_in_raw'], (1 << header['board_dig_in_channels'][i]['native_order'])), 0)\n\n # Extract digital output channels to separate variables.\n for i in range(header['num_board_dig_out_channels']):\n data['board_dig_out_data'][i, :] = np.not_equal(np.bitwise_and(data['board_dig_out_raw'], (1 << header['board_dig_out_channels'][i]['native_order'])), 0)\n\n # Scale voltage levels appropriately.\n data['amplifier_data'] = np.multiply(0.195, (data['amplifier_data'].astype(np.int32) - 32768)) # units = microvolts\n data['aux_input_data'] = np.multiply(37.4e-6, data['aux_input_data']) # units = volts\n data['supply_voltage_data'] = np.multiply(74.8e-6, data['supply_voltage_data']) # units = volts\n if header['eval_board_mode'] == 1:\n data['board_adc_data'] = np.multiply(152.59e-6, (data['board_adc_data'].astype(np.int32) - 32768)) # units = volts\n elif header['eval_board_mode'] == 13:\n data['board_adc_data'] = np.multiply(312.5e-6, (data['board_adc_data'].astype(np.int32) - 32768)) # units = volts\n else:\n data['board_adc_data'] = np.multiply(50.354e-6, data['board_adc_data']) # units = volts\n data['temp_sensor_data'] = np.multiply(0.01, data['temp_sensor_data']) # units = deg C\n\n # Check for gaps in timestamps.\n num_gaps = np.sum(np.not_equal(data['t_amplifier'][1:]-data['t_amplifier'][:-1], 1))\n if num_gaps == 0:\n print('No missing timestamps in data.')\n else:\n print('Warning: {0} gaps in timestamp data found. Time scale will not be uniform!'.format(num_gaps))\n\n # Scale time steps (units = seconds).\n data['t_amplifier'] = data['t_amplifier'] / header['sample_rate']\n data['t_aux_input'] = data['t_amplifier'][range(0, len(data['t_amplifier']), 4)]\n data['t_supply_voltage'] = data['t_amplifier'][range(0, len(data['t_amplifier']), header['num_samples_per_data_block'])]\n data['t_board_adc'] = data['t_amplifier']\n data['t_dig'] = data['t_amplifier']\n data['t_temp_sensor'] = data['t_supply_voltage']\n\n # If the software notch filter was selected during the recording, apply the\n # same notch filter to amplifier data here.\n if header['notch_filter_frequency'] > 0 and header['version']['major'] < 3:\n print('Applying notch filter...')\n\n print_increment = 10\n percent_done = print_increment\n for i in range(header['num_amplifier_channels']):\n data['amplifier_data'][i,:] = notch_filter(data['amplifier_data'][i,:], header['sample_rate'], header['notch_filter_frequency'], 10)\n\n fraction_done = 100 * (i / header['num_amplifier_channels'])\n if fraction_done >= percent_done:\n print('{}% done...'.format(percent_done))\n percent_done += print_increment\n else:\n data = [];\n\n # Move variables to result struct.\n result = data_to_result(header, data, data_present)\n\n print('Done! Elapsed time: {0:0.1f} seconds'.format(time.time() - tic))\n return result","def generate_sample(sample_size, multiplicity, sample_name, height, width, treble_tp_key, bass_tp_key, treble_cp_key, bass_cp_key, rest_prob, measure_length_choices=(8, 12, 16), key_number_choices=tuple(range(-7, 8))):\n \n t = time.time()\n if not os.path.exists(sample_name + '/'):\n os.mkdir(sample_name + '/')\n \n # the neural net needs images of measures, pseudocode for those images, and the key and time signatures of those measures\n pc_data = []\n images = []\n measure_lengths = []\n key_numbers = []\n \n for i in range(sample_size):\n print(f'{i}/{sample_size} time: {time.time() - t} seconds')\n \n # pick random key and time signatures\n measure_length = np.random.choice(measure_length_choices)\n key_number = np.random.choice(key_number_choices)\n \n # generate the xml for a measure\n soup = generate_measure(measure_length, key_number, rest_prob, treble_tp_key, bass_tp_key, treble_cp_key, bass_cp_key)\n \n # write the xml to a file\n with open('temp.musicxml', 'w+') as f:\n f.write(str(soup))\n \n # call musescore to convert the xml to a png and and svg\n subprocess.call(['mscore', '-S', str(pathlib.Path.home()) + '/Documents/MuseScore2/Styles/custom_style.mss', 'temp.musicxml', '-o', 'temp.mscx'])\n subprocess.call(['mscore', 'temp.mscx', '-o', 'temp.png'])\n subprocess.call(['mscore', 'temp.mscx', '-o', 'temp.svg'])\n png_path = 'temp-1.png'\n svg_path = 'temp-1.svg'\n \n # create multiple copies of the measure, with the image distorted in different ways\n for _ in range(multiplicity):\n # use the png and svg to appropriately crop the image\n image = crop(png_path, svg_path)\n \n # distort the image\n image = random_augmentation(image, height, width)\n \n # make sure the image is encoded as an integer, to save space\n image = (image*255).astype(np.uint8)\n \n # add the image data to the lists\n images.append(image)\n measure_lengths.append(measure_length)\n key_numbers.append(key_number)\n\n # record the pseucode, instead of the xml\n # this line has to go down here since xml_to_pc changes soup in place\n pc = ['<START>'] + xml_to_pc(soup) + ['<END>']\n for _ in range(multiplicity):\n pc_data.append(pc)\n \n # remove the files used in constructing the sample item\n os.remove('temp.musicxml')\n os.remove('temp.mscx')\n os.remove('temp-1.png')\n os.remove('temp-1.svg')\n \n # after generating the sample, save it to a folder\n with open(sample_name + '/' + 'pc_data.json', 'w+') as f:\n json.dump(pc_data, f)\n measure_lengths = np.array(measure_lengths)\n key_numbers = np.array(key_numbers)\n images = np.array(images)\n np.save(sample_name + '/' + 'measure_lengths.npy', measure_lengths)\n np.save(sample_name + '/' + 'key_numbers.npy', key_numbers)\n np.save(sample_name + '/' + 'images.npy', images)\n \n time_elapsed = time.time() - t\n \n # save info about the sample to a text file\n info = {'sample_name': sample_name,\n 'sample_size': sample_size,\n 'multiplicity': multiplicity,\n 'treble_tp_key': treble_tp_key,\n 'bass_tp_key': bass_tp_key,\n 'treble_cp_key': treble_cp_key,\n 'bass_cp_key': bass_cp_key,\n 'rest_prob': rest_prob,\n 'measure_length_choices': list(measure_length_choices),\n 'key_number_choices': list(key_number_choices),\n 'time_elapsed': time_elapsed}\n with open(sample_name + '/' + 'info.json', 'w+') as f:\n json.dump(info, f)","def sample(self):\n raise NotImplementedError(\"Override me!\")","def fill_buffer(self):\n num_of_smp = 0\n while num_of_smp < self.buf_size:\n c, t = self.inlet.pull_chunk(timeout=0.0)\n new_c = []\n new_t = []\n while c:\n new_c += c\n new_t += t\n c, t = self.inlet.pull_chunk(timeout=0.0)\n\n # add samples to buffer\n if any(new_c):\n # add samples\n num_of_smp += len(new_c)\n data_v = [item for sublist in new_c for item in sublist]\n self.gbuffer = np.roll(self.gbuffer, -len(data_v))\n self.gbuffer[-len(data_v):] = data_v\n # add timestamps\n if new_t:\n self.gtimes = np.roll(self.gtimes, -len(new_t))\n self.gtimes[-len(new_t):] = new_t","def __init__(self, n_per_sample, title, unit):\n self.min_sample = 0xffffffffffffffff\n self.max_sample = 0\n self.n_per_sample = n_per_sample\n self.title = title\n self.unit = unit\n self.sum_ = 0\n self.count = 0\n self.sample_lock = threading.Lock()","def samples():\n f = open(config['samples'], \"r\")\n samp=[]\n for line in f:\n samp.append(line.strip().split()[0])\n return samp","def _set_sample(self, sample, PB_X, t):\n for sensor in PB_X.keys():\n sample.set(sensor, np.array(PB_X[sensor]), t=t+1)","def _handler_sample(self, *args, **kwargs):\n next_state = None\n timeout = time.time() + SAMPLE_TIMEOUT\n\n for i in self._units:\n self._do_command(Command.READ, i)\n\n particles = self.wait_for_particles([DataParticleType.D1000_PARSED], timeout)\n\n return next_state, (next_state, particles)","def merge_evio_skims(run, seqno, slices):\n inset = {\"BCAL-LED\": \"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.BCAL-LED.evio\",\n \"DIRC-LED\": \"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.DIRC-LED.evio\",\n \"FCAL-LED\": \"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.FCAL-LED.evio\",\n \"CCAL-LED\": \"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.CCAL-LED.evio\",\n \"random\": \"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.random.evio\",\n \"omega\": \"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.omega.evio\",\n \"sync\": \"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.sync.evio\",\n \"ps\": \"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.ps.evio\",\n }\n outset = {\"BCAL-LED\": \"BCAL-LED_{0:06d}_{1:03d}.evio\",\n \"DIRC-LED\": \"DIRC-LED_{0:06d}_{1:03d}.evio\",\n \"FCAL-LED\": \"FCAL-LED_{0:06d}_{1:03d}.evio\",\n \"CCAL-LED\": \"CCAL-LED_{0:06d}_{1:03d}.evio\",\n \"random\": \"random_{0:06d}_{1:03d}.evio\",\n \"omega\": \"omega_{0:06d}_{1:03d}.evio\",\n \"sync\": \"sync_{0:06d}_{1:03d}.evio\",\n \"ps\": \"ps_{0:06d}_{1:03d}.evio\",\n }\n badslices = []\n slicepatt = re.compile(r\"([1-9][0-9]*),([1-9][0-9]*)/\")\n for iset in inset:\n ofile = outset[iset].format(run, seqno)\n ifiles = []\n for sl in slices:\n ifile = \"{0},{1}/\".format(sl[0], sl[1]) +\\\n inset[iset].format(run, seqno, sl[0], sl[1])\n if iset == \"sync\" and not os.path.exists(ifile):\n print(\"Warning in merge_evio_skims - \",\n \"missing sync event skim \",\n \"in slice {0},{1}\".format(sl[0], sl[1])\n )\n continue\n elif iset == \"omega\" and not os.path.exists(ifile):\n print(\"Warning in merge_evio_skims - \",\n \"missing omega event skim \",\n \"in slice {0},{1}\".format(sl[0], sl[1])\n )\n continue\n ifiles.append(ifile)\n cmd = subprocess.Popen([\"eviocat\", \"-o\", ofile] + ifiles,\n stderr=subprocess.PIPE)\n elog = cmd.communicate()\n if cmd.returncode != 0:\n for eline in elog[1].decode(\"ascii\").split('\\n'):\n badslice = slicepatt.search(eline)\n if badslice:\n badslices.append(\"{0},{1}\".format(badslice.group(1),\n badslice.group(2)))\n sys.stderr.write(eline + '\\n')\n sys.stderr.write(\"Error on output file {0}\".format(ofile) +\n \" - evio file merging failed!\\n\")\n sys.stderr.flush()\n continue\n odir = output_area + \"/\" + iset + \"/{0:06d}\".format(run)\n upload(ofile, odir)\n return badslices","def run(self):\n\t\trun_start_timestamp = time.clock()\n\t\texperiment_start_time = time.strftime(\"%H_%M_%S_%m_%d_%Y\", time.localtime())\n\t\tprint \"starting dataset at {}\\n\".format(experiment_start_time)\n\t\tdata_file = \"raw_data/data_\" + experiment_start_time + \".csv\"\n\t\twith open(data_file, 'a') as f:\n\t\t\tf.write(\"Packet, Sample offset, Latency (ms), Sample\\n\")\n\n\t\t##### EXPERIMENT SETUP #####\n\t\t# sample for a max of 1.5 seconds\n\t\t# approximate number of samples assuming ~500ms latency per packet\n\t\tnSamples = (int) (1.5 * self.sampling_freq)\n\n\t\t#csamples, lost, corrupted\n\t\tbuffer_info = [0, 0, 0]\n\n\t\tnum_packets_received = 0\n\t\tnum_packets_missed = 0\n\t\tnum_acks_missed = 0\n\n\t\t# array to hold indices of packets missed\n\t\tpacket_number_missed = []\n\n\t\t# num_packets_received + num_packets_missed must equal num_tries\n\t\tnum_tries = 0\n\n\t\t# ready for next button press if previous packet has been handled\n\t\t# and if instruments, variables are configured for next packet\n\t\tlast_packet_handled = True\n\t\t# keep track of if current packet has been received\n\t\tpacket_received = True\n\n\t\t#keep track of previous packet acknowledgment\n\t\tack_missed = False\n\n\t\t##### END SETUP #####\n\n\t\t##### MAIN LOOP of experiment. #####\n\t\t# runs for the duration of the experiment\n\t\t#note: openmote toggles its pins every packet creation and reception\n\n\t\twhile num_tries < self.num_packets_experiment:\n\t\t\t# initialize \"trash\" array to clear all buffer samples before starting button press\n\t\t\t# this must be able to hold 4096 samples, 2 bytes each\n\t\t\ttrashSamples = (c_uint16 * 4096)()\n\n\t\t\t#clear buffer\n\t\t\tbuffer_info = self._copy_buffer_samples(buffer_info, nSamples, trashSamples, copy_all_samples=True)\n\n\t\t\t# clear rgwSamples for next packet\n\t\t\trgwSamples = (c_uint16 * nSamples)()\n\n\t\t\t# reset and configure DigitalIO\n\t\t\tsteady_state_DIO = self._configure_DigitalIO()\n\n\t\t\t# reset and configure DigitalIn to take nSamples on trigger\n\t\t\t# set DigitalIn trigger when button_press_mirror_bit channel is raised (this should start sampling)\n\t\t\tself._configure_DigitalIn(nSamples, self.button_press_mirror_bit)\n\n\t\t\tready_for_next_button_press = True\n\t\t\tbroke_early = False\n\n\t\t\t#print \"begin acquisition {}\".format(num_tries + 1)\n\t\t\tprev_csamples, curr_csamples = 0, 0\n\n\t\t\tif ack_missed:\n\t\t\t\tprint \"missed ack\"\n\t\t\t\ttime.sleep(0.55)\n\n\n\t\t\t# inner loop: runs from button press until packet received.\n\t\t\twhile buffer_info[0] < nSamples:\n\n\t\t\t\t# button press\n\t\t\t\tif last_packet_handled and ready_for_next_button_press:\n\t\t\t\t\t# we can send the next packet because the last packet was handled (received or understood to be missed)\n\t\t\t\t\t# and instruments are configured\n\t\t\t\t\t# button press -> set value on enabled AD2 output pins (digital_out_channels_bits)\n\t\t\t\t\t# AD2 output is hard wired to button press input which triggers acquisition\n\n\t\t\t\t\t#get current value of packet_received_pin; when packet is received this will toggle\n\t\t\t\t\tcurr_DIO = self._get_DIO_values()\n\t\t\t\t\tpacket_received_pins_state = curr_DIO & self.packet_received_bits\n\t\t\t\t\tpacket_created_pin_state = curr_DIO & self.packet_created_bit\n\n\t\t\t\t\tlast_packet_handled = False\n\t\t\t\t\tready_for_next_button_press = False\n\t\t\t\t\tpacket_received = False\n\t\t\t\t\tack_missed = False\n\n\t\t\t\t\t# press the button. all other outputs go low.\n\t\t\t\t\tdwf.FDwfDigitalIOOutputSet(self.interface_handler, c_uint16(self.button_press_bit))\n\t\t\t\t\t#reset all enabled digital out channels back to steady state (all high except button press)\n\t\t\t\t\tdwf.FDwfDigitalIOOutputSet(self.interface_handler, steady_state_DIO)\n\t\t\t\t\t\n\t\t\t\t\t#print \"button pressed\"\n\t\t\t\t\tnum_tries += 1\n\n\t\t\t\t# copy buffer samples to memory and flush\n\t\t\t\t#print \"Before: {}\".format(buffer_info)\n\t\t\t\tbuffer_info = self._copy_buffer_samples(buffer_info, nSamples, rgwSamples)\n\t\t\t\t#print \"After: {}\".format(buffer_info)\n\t\t\t\t#buffer_flush_stop = time.clock()\n\n\t\t\t\tcurr_csamples = buffer_info[0]\n\t\t\t\tif curr_csamples == prev_csamples:\n\t\t\t\t\tprint \"broke early\"\n\t\t\t\t\tnum_tries -= 1\n\t\t\t\t\tbroke_early = True\n\n\t\t\t\t\t# stop sampling\n\t\t\t\t\tdwf.FDwfDigitalInConfigure(self.interface_handler, c_bool(0), c_bool(0))\n\t\t\t\t\tbreak\n\n\t\t\t\t# manually stop sampling once packet_received_bit is not equal to its pin state\n\t\t\t\tcurr_DIO = self._get_DIO_values()\n\t\t\t\tif ((curr_DIO & self.packet_received_bits) != packet_received_pins_state):\n\t\t\t\t\t#copy last buffer samples to memory\n\t\t\t\t\tbuffer_info = self._copy_buffer_samples(buffer_info, nSamples, rgwSamples, last_read=True)\n\n\t\t\t\t\t# packet_received_bit toggled; stop sampling\n\t\t\t\t\tdwf.FDwfDigitalInConfigure(self.interface_handler, c_bool(0), c_bool(0))\n\n\t\t\t\t\tcurr_DIO = self._get_DIO_values()\n\t\t\t\t\tif (curr_DIO & self.packet_created_bit) != packet_created_pin_state:\n\t\t\t\t\t\tack_missed = True\n\n\t\t\t\t\tpacket_received = True\n\t\t\t\t\tnum_packets_received += 1\n\t\t\t\t\t#print \"received packet {}\".format(num_tries)\n\n\t\t\t\t\tbreak\n\n\t\t\t\tprev_csamples = curr_csamples\n\t\t\t\t# end of the inner loop\n\n\t\t\t#set this so we can push button again\n\t\t\tlast_packet_handled = True\n\n\t\t\tif broke_early:\n\t\t\t\tcontinue\n\n\t\t\t# reach here if packet was received OR if 1.5 million samples have been taken\n\t\t\tif packet_received == True:\n\t\t\t\tself.postprocess(num_tries, buffer_info, rgwSamples, data_file)\n\n\t\t\telse:\n\t\t\t\t# we took 1.5 million samples and supposedly missed the packet\n\t\t\t\tnum_packets_missed += 1\n\t\t\t\tpacket_number_missed.append(num_tries)\n\t\t\t\tself.postprocess(num_tries, buffer_info, rgwSamples, data_file, missed_packet=True)\n\t\t\t\t# set last_packet_handled to True to try button press again\n\n\n\t\trun_end_timestamp = time.clock()\n\t\tprint \"Done with experiment\"\n\t\t#print all packets sent, lost, total info\n\t\tprint \"Number of tries: {}\".format(num_tries)\n\t\tprint \"Number of received packets: {}\".format(num_packets_received)\n\t\tprint \"Number of missed packets: {}\\n\".format(num_packets_missed)\n\t\tprint \"Total duration: {} seconds\".format(run_end_timestamp - run_start_timestamp)\n\t\treturn","def get_data():\n \n data = {\n 'loadAvg1Min': 0, #load average 1 min\n 'loadAvg5Min': 0, #load average 5 min\n 'loadAvg15Min': 0, #load average 15 min\n 'cpuUsage': [], #usage distribution for each cpu\n 'memUsage': {}, #memory usage \n 'networkReads': [], #network reads per second for each interface\n 'networkWrites': [], #network writes per second for each interface\n 'diskReads': [], #disk reads per second for each disk\n 'diskWrites': [] #disk writes per second for each disk\n }\n \n #metrics that doesnt need sampling\n data['loadAvg1Min'], data['loadAvg5Min'], data['loadAvg15Min'] = get_load_avg() #get load avg\n data['memUsage'].update(get_mem_usage()) #memory usage\n \n #metrics that needs sampling\n #they are written as a generator so that we can sleep before collection again\n sampling_duration = 1\n cpu_usage_gen = get_cpu_usage(sampling_duration) #generator for cpu usage\n net_rw_gen = get_net_rw(sampling_duration) #generator for network read write\n disk_rw_gen = get_disk_rw(sampling_duration) #generator for disk read write\n \n while 1: #now start sampling, whenever we have walid data, we can exit the loop\n cpu_usage = next(cpu_usage_gen)\n net_rw = next(net_rw_gen)\n disk_rw = next(disk_rw_gen)\n \n if cpu_usage or net_rw or disk_rw: #we have valid data\n break\n \n time.sleep(sampling_duration)\n \n #append cpu usage for each cpu core\n for cpu, usage in cpu_usage.items():\n data['cpuUsage'].append({'name': cpu, 'value': usage})\n \n #append network read and write for each interface\n for interface, rw in net_rw.items():\n data['networkReads'].append({'name': interface, 'value': rw['reads']})\n data['networkWrites'].append({'name': interface, 'value': rw['writes']}) \n \n #append disk read and write for each logical disk\n for device, rw in disk_rw.items():\n data['diskReads'].append({'name': device, 'value': rw['reads']})\n data['diskWrites'].append({'name': device, 'value': rw['writes']})\n \n return data","def collect_samples(serialPort,NO_SENSORS,NO_SAMPLES,log):\n run = '1'\n badSamples = 0\n count = 1\n log_temp = []\n temp = [0] * 20\n NO_FIELDS = (NO_SENSORS * 3) + 1\n \n while (run == '1'):\n # If the input buffer is not empty read the data out into rawData using \\n as a delimiter.\n if (serialPort.inWaiting()>0):\n rawData = serialPort.readline()\n print(rawData)\n \n # If invalid data is recieved this prevents program crash\n try:\n # Decode the bytes into a string\n data = rawData.decode()\n \n # Split x, y, z and newline values into a list\n if (count >= (NO_SAMPLES + 1)):\n endTime_temp = data.split(\" \", 2)\n if (len(endTime_temp) == 2 and '' not in endTime_temp):\n endTime = int(endTime_temp[0])\n else:\n endTime = 780\n print('Time not recieved')\n print('Lost Samples: ' + str(badSamples))\n run = '0'\n else:\n data_readings = data.split(\" \", NO_FIELDS)\n print(data_readings)\n \n # A correct sample should contain 16 values and not include null and so this is used\n # to validate the data and record any samples that are discarded in this way\n if (len(data_readings) == NO_FIELDS and '' not in data_readings):\n # Discard newline characters before saving data\n int_data_readings = list(map(int,data_readings[:(NO_FIELDS - 1)]))\n log_temp.append(int_data_readings)\n else:\n badSamples += 1\n except:\n print('Invalid data recieved')\n \n count += 1\n\n samplingPeriod = (endTime/NO_SAMPLES)/NO_SENSORS\n timeStamp = 0.0\n\n for i in range(0,len(log_temp)):\n for j in range(0,NO_SENSORS):\n temp[0+(j*4)] = log_temp[i][0+(j*3)]\n temp[1+(j*4)] = log_temp[i][1+(j*3)]\n temp[2+(j*4)] = log_temp[i][2+(j*3)]\n temp[3+(j*4)] = timeStamp\n timeStamp += samplingPeriod\n log.append(temp.copy())","def sample_record(self, chunkdata):\n version = chunkdata[0:4]\n if version == V6_VERSION:\n record_size = self.v6_struct.size\n elif version == V5_VERSION:\n record_size = self.v5_struct.size\n elif version == V4_VERSION:\n record_size = self.v4_struct.size\n elif version == V3_VERSION:\n record_size = self.v3_struct.size\n else:\n return\n\n for i in range(0, len(chunkdata), record_size):\n if self.sample > 1:\n # Downsample, using only 1/Nth of the items.\n if random.randint(0, self.sample - 1) != 0:\n continue # Skip this record.\n\n record = chunkdata[i:i + record_size]\n # for earlier versions, append fake bytes to record to maintain size\n if version == V3_VERSION:\n # add 16 bytes of fake root_q, best_q, root_d, best_d to match V4 format\n record += 16 * b'\\x00'\n if version == V3_VERSION or version == V4_VERSION:\n # add 12 bytes of fake root_m, best_m, plies_left to match V5 format\n record += 12 * b'\\x00'\n # insert 4 bytes of classical input format tag to match v5 format\n record = record[:4] + CLASSICAL_INPUT + record[4:]\n if version == V3_VERSION or version == V4_VERSION or version == V5_VERSION:\n # add 48 byes of fake result_q, result_d etc\n record += 48 * b'\\x00'\n\n if version == V6_VERSION:\n # diff focus code, peek at best_q, orig_q and pol_kld from record (unpacks as tuple with one item)\n best_q = struct.unpack('f', record[8284:8288])[0]\n orig_q = struct.unpack('f', record[8328:8332])[0]\n pol_kld = struct.unpack('f', record[8348:8352])[0]\n\n # if orig_q is NaN or pol_kld is 0, accept, else accept based on diff focus\n if not np.isnan(orig_q) and pol_kld > 0:\n diff_q = abs(best_q - orig_q)\n q_weight = self.diff_focus_q_weight\n pol_scale = self.diff_focus_pol_scale\n total = (q_weight * diff_q + pol_kld) / (q_weight +\n pol_scale)\n thresh_p = self.diff_focus_min + self.diff_focus_slope * total\n if thresh_p < 1.0 and random.random() > thresh_p:\n continue\n\n yield record","def sample(self, length):\n pass","def sample(self, size=1):\n raise NotImplementedError"],"string":"[\n \"def samples(self):\\n pass\",\n \"def _read_cardiochip(self):\\n cur_leadstatus = 0\\n sample_count =0\\n while self.connected:\\n sample_count+=1\\n #check for sync bytes\\n readbyte = ord(self.ser.read(1))\\n #print readbyte, SYNC_BYTE\\n if readbyte != SYNC_BYTE:\\n continue\\n readbyte = ord(self.ser.read(1))\\n if readbyte != SYNC_BYTE:\\n continue\\n\\n #parse length byte\\n while True:\\n pLength = ord(self.ser.read(1))\\n if pLength != SYNC_BYTE:\\n break\\n if pLength > 169:\\n continue\\n #print \\\"L: %i\\\" % pLength\\n\\n # collect payload bytes\\n payload = self.ser.read(pLength)\\n payload = [ord(x) for x in payload] #convert to int from string\\n #print \\\"payload: \\\" + str(payload).strip('[]')\\n # ones complement inverse of 8-bit payload sum\\n checksum = sum(payload) & 0xFF\\n checksum = ~checksum & 0xFF\\n\\n # catch and verify checksum byte\\n chk = ord(self.ser.read(1))\\n #print \\\"chk: \\\" + str(checksum)\\n if chk != checksum:\\n print \\\"checksum error, %i != %i\\\" % (chk, checksum)\\n continue\\n\\n output = self._parseData(payload)\\n\\n lead_status = next(( d for d in output if 'leadoff' in d), None)\\n if lead_status is not None:\\n if cur_leadstatus != lead_status['leadoff']:\\n #we have a change\\n if lead_status['leadoff']==200:\\n print \\\"LEAD ON\\\"\\n elif lead_status['leadoff']==0:\\n print \\\"LEAD OFF\\\"\\n cur_leadstatus = lead_status['leadoff']\\n\\n # store the output data in a queue\\n # first, create a tuple with the sample index and dict with the timestamp and ecg\\n ecgdict = next(((i,d) for i,d in enumerate(output) if 'ecg_raw' in d), None)\\n if ecgdict is not None and sample_count>self.Fs*2:\\n #let's just ignore the first 2 seconds of crappy data\\n ecgdict[1]['leadoff'] = cur_leadstatus\\n #print ecgdict[1]\\n self.ecg_buffer.put(ecgdict[1]) # this should save the ecg and timestamp keys\\n\\n return\",\n \"def addSamples(file, spec, data_card, channel_bins, samples, shapefile):\\n data_card.processes = samples\\n\\n for idxc, channel in enumerate(spec[\\\"channels\\\"]):\\n if data_card.hasShapes == False: # counting\\n for sample in channel[\\\"samples\\\"]:\\n data_card.exp[channel[\\\"name\\\"]].update(\\n {sample[\\\"name\\\"]: sample[\\\"data\\\"][0]}\\n )\\n else:\\n # shapes\\n data_card.shapeMap.update({channel[\\\"name\\\"]: {}})\\n data_card.shapeMap[channel[\\\"name\\\"]].update(\\n {\\\"data_obs\\\": [shapefile, channel[\\\"name\\\"] + \\\"/\\\" + \\\"data_obs\\\"]}\\n )\\n for idxs, sample in enumerate(channel[\\\"samples\\\"]):\\n data = sum(sample[\\\"data\\\"])\\n data_card.exp[channel[\\\"name\\\"]].update({sample[\\\"name\\\"]: data})\\n\\n mods = [\\n spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"modifiers\\\"][i][\\\"type\\\"]\\n for i, mod in enumerate(\\n spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"modifiers\\\"]\\n )\\n ]\\n if \\\"histosys\\\" in mods:\\n # if shape uncertainty histogram is available\\n data_card.shapeMap[channel[\\\"name\\\"]].update(\\n {\\n spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"name\\\"]: [\\n shapefile,\\n channel[\\\"name\\\"]\\n + \\\"/\\\"\\n + spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"name\\\"],\\n channel[\\\"name\\\"]\\n + \\\"/\\\"\\n + spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"name\\\"]\\n + \\\"_$SYSTEMATIC\\\",\\n ]\\n }\\n )\\n else:\\n data_card.shapeMap[channel[\\\"name\\\"]].update(\\n {\\n spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"name\\\"]: [\\n shapefile,\\n channel[\\\"name\\\"]\\n + \\\"/\\\"\\n + spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"name\\\"],\\n ]\\n }\\n )\\n if \\\"staterror\\\" in mods:\\n # if staterror is present, provide variances for histograms\\n h_data = hist.Hist.new.Regular(\\n channel_bins[channel[\\\"name\\\"]], 0, channel_bins[channel[\\\"name\\\"]]\\n ).Weight()\\n\\n h_data[...] = np.stack(\\n [\\n spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"data\\\"],\\n [\\n i**2\\n for i in spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\n \\\"modifiers\\\"\\n ][mods.index(\\\"staterror\\\")][\\\"data\\\"]\\n ],\\n ],\\n axis=-1,\\n )\\n data_card.binParFlags.update({channel[\\\"name\\\"]: True})\\n elif \\\"shapesys\\\" in mods: # for shapesys, also provide variances\\n h_data = hist.Hist.new.Regular(\\n channel_bins[channel[\\\"name\\\"]], 0, channel_bins[channel[\\\"name\\\"]]\\n ).Weight()\\n h_data[...] = np.stack(\\n [\\n spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"data\\\"],\\n [\\n i**2\\n for i in spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\n \\\"modifiers\\\"\\n ][mods.index(\\\"shapesys\\\")][\\\"data\\\"]\\n ],\\n ],\\n axis=-1,\\n )\\n data_card.binParFlags.update({channel[\\\"name\\\"]: True})\\n else: # no staterror or shapesys->0 variance\\n h_data = hist.Hist.new.Regular(\\n channel_bins[channel[\\\"name\\\"]], 0, channel_bins[channel[\\\"name\\\"]]\\n ).Weight()\\n h_data[...] = np.stack(\\n [\\n spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"data\\\"],\\n [0 for _ in range(channel_bins[channel[\\\"name\\\"]])],\\n ],\\n axis=-1,\\n )\\n file[\\n channel[\\\"name\\\"]\\n + \\\"/\\\"\\n + spec[\\\"channels\\\"][idxc][\\\"samples\\\"][idxs][\\\"name\\\"]\\n ] = h_data\",\n \"def get_next_sample(self):\",\n \"def get_cui_sample_it(self):\\n while True:\\n i = rd.sample(range(len(self.id2sense)), 1)[0]\\n cui = self.id2sense[i]\\n if cui in self.cui2def:\\n sdef = self.cui2def[cui]\\n else:\\n sdef = [self.voc.encode(PAD)] * self.model_config.max_def_len\\n\\n if cui in self.cui2stype:\\n stype = self.cui2stype[cui]\\n else:\\n stype = self.stype2id['unk']\\n\\n for abbr_id in self.cuiud2abbrid[i]:\\n obj = {\\n 'abbr_id': abbr_id,\\n 'cui_id': i,\\n 'def': sdef,\\n 'stype': stype}\\n yield obj\",\n \"def repackageSamples(pinsToMeasure, pinMap, nMilliBlocks, samples):\\n\\n channels = [None, None, None, None]\\n for pinName in pinsToMeasure:\\n channels[pinMap[pinName]] = ( { \\\"pinName\\\": pinName, \\\"isAudio\\\": isAudio(pinName), \\\"min\\\": [], \\\"max\\\": [] } )\\n\\n i = 0\\n for blk in range(0, nMilliBlocks):\\n for channel in channels:\\n if channel != None:\\n channel[\\\"max\\\"].append(ord(samples[i]))\\n i += 1\\n channel[\\\"min\\\"].append(ord(samples[i]))\\n i += 1\\n\\n return channels\",\n \"def getBarySamples(self):\\n self.XC1Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.XC2Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.c1Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.c2Fields = np.zeros([self.nSample, self.nCell_cfd])\\n self.c3Fields = np.zeros([self.nSample, self.nCell_cfd])\\n\\n for isamp in np.arange(self.nSample):\\n TauNew = self.TauSample[isamp, :, :]\\n k,V1,V2,V3,C,NP = self.mapTau._tau2PhysParams(TauNew)\\n X = self.mapTau._C2X(C)\\n \\n self.c1Fields[isamp, :] = C[:, 0]\\n self.c2Fields[isamp, :] = C[:, 1]\\n self.c3Fields[isamp, :] = C[:, 2]\\n \\n \\n self.XC1Fields[isamp, :] = X[:, 0]\\n self.XC2Fields[isamp, :] = X[:, 1]\\n \\n # Get base C1 and C2 field\\n k,V1,V2,V3,C,NP = self.mapTau._tau2PhysParams(self.Taubar)\\n X = self.mapTau._C2X(C)\\n \\n self.c1Field_base = C[:, 0]\\n self.c2Field_base = C[:, 1]\\n self.c3Field_base = C[:, 2]\\n\\n self.XC1Field_base = X[:, 0]\\n self.XC2Field_base = X[:, 1] \\n\\n np.savetxt(self.resultDir+'RComponent_samples/XC1_s', self.XC1Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/XC2_s', self.XC2Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/XC1_base', self.XC1Field_base)\\n np.savetxt(self.resultDir+'RComponent_samples/XC2_base', self.XC2Field_base)\\n\\n np.savetxt(self.resultDir+'RComponent_samples/c1_s', self.c1Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/c2_s', self.c2Fields)\\n np.savetxt(self.resultDir+'RComponent_samples/c3_s', self.c3Fields) \\n np.savetxt(self.resultDir+'RComponent_samples/c1_base', self.c1Field_base)\\n np.savetxt(self.resultDir+'RComponent_samples/c2_base', self.c2Field_base) \\n np.savetxt(self.resultDir+'RComponent_samples/c3_base', self.c3Field_base)\",\n \"def __getitem__(self, item):\\n c_ex = self.examples[item]\\n # randomly select ref mic\\n mics = [x for x in c_ex.keys()]\\n if self.train:\\n np.random.shuffle(mics) # randomly permute during training to change ref mics\\n\\n mixtures = []\\n sources = []\\n for i in range(len(mics)):\\n c_mic = c_ex[mics[i]]\\n\\n if self.segment:\\n offset = 0\\n if c_mic[\\\"length\\\"] > int(self.segment * self.sample_rate):\\n offset = np.random.randint(\\n 0, c_mic[\\\"length\\\"] - int(self.segment * self.sample_rate)\\n )\\n\\n # we load mixture\\n mixture, fs = sf.read(\\n c_mic[\\\"mixture\\\"],\\n start=offset,\\n stop=offset + int(self.segment * self.sample_rate),\\n dtype=\\\"float32\\\",\\n )\\n spk1, fs = sf.read(\\n c_mic[\\\"spk1\\\"],\\n start=offset,\\n stop=offset + int(self.segment * self.sample_rate),\\n dtype=\\\"float32\\\",\\n )\\n spk2, fs = sf.read(\\n c_mic[\\\"spk2\\\"],\\n start=offset,\\n stop=offset + int(self.segment * self.sample_rate),\\n dtype=\\\"float32\\\",\\n )\\n else:\\n mixture, fs = sf.read(c_mic[\\\"mixture\\\"], dtype=\\\"float32\\\") # load all\\n spk1, fs = sf.read(c_mic[\\\"spk1\\\"], dtype=\\\"float32\\\")\\n spk2, fs = sf.read(c_mic[\\\"spk2\\\"], dtype=\\\"float32\\\")\\n\\n mixture = torch.from_numpy(mixture).unsqueeze(0)\\n spk1 = torch.from_numpy(spk1).unsqueeze(0)\\n spk2 = torch.from_numpy(spk2).unsqueeze(0)\\n\\n assert fs == self.sample_rate\\n mixtures.append(mixture)\\n sources.append(torch.cat((spk1, spk2), 0))\\n\\n mixtures = torch.cat(mixtures, 0)\\n sources = torch.stack(sources)\\n # we pad till max_mic\\n valid_mics = mixtures.shape[0]\\n if mixtures.shape[0] < self.max_mics:\\n dummy = torch.zeros((self.max_mics - mixtures.shape[0], mixtures.shape[-1]))\\n mixtures = torch.cat((mixtures, dummy), 0)\\n sources = torch.cat((sources, dummy.unsqueeze(1).repeat(1, sources.shape[1], 1)), 0)\\n return mixtures, sources, valid_mics\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def sample(self):\\r\\n raise NotImplementedError\",\n \"def activatePinReading(self):\\n\\n for pin in self.pinsToMeasure:\\n arduino.samplePinDuringCapture(self.f, self.pinMap[pin], self.wallClock)\",\n \"def render(self, downsamp=1):\\n \\n # first determine if time is provided, if not assume all start at zero\\n # and last the duration of sonification\\n\\n if \\\"time\\\" not in self.sources.mapping:\\n self.sources.mapping['time'] = [0.] * self.sources.n_sources\\n self.sources.mapping['note_length'] = [self.score.length] * self.sources.n_sources\\n \\n # index each chord\\n cbin = np.digitize(self.sources.mapping['time'], self.score.fracbins, 0)\\n cbin = np.clip(cbin-1, 0, self.score.nchords-1)\\n\\n # pitch rank of each source divided by the number of sources\\n pitchfrac = np.empty_like(self.sources.mapping['pitch'])\\n pitchfrac[np.argsort(self.sources.mapping['pitch'])] = np.arange(self.sources.n_sources)/self.sources.n_sources\\n\\n # get some relevant numbers before iterating through sources\\n Nsamp = self.out_channels['0'].values.size\\n lastsamp = Nsamp - 1\\n Nchan = len(self.out_channels.keys())\\n indices = range(0,self.sources.n_sources, downsamp)\\n\\n for source in tqdm(indices):\\n\\n # index note properties\\n t = self.sources.mapping['time'][source]\\n tsamp = int(Nsamp * t)\\n chord = self.score.note_sequence[cbin[source]]\\n nints = self.score.nintervals[cbin[source]]\\n pitch = pitchfrac[source]\\n note = chord[int(pitch * nints)]\\n # make dictionary for feeding to play function with each notes properties\\n sourcemap = {}\\n # for k in self.sources.mapping.keys():\\n # sourcemap[k] = self.soures.mapping[k][source]\\n nested_dict_idx_reassign(self.sources.mapping, sourcemap, source)\\n sourcemap['note'] = note\\n\\n # run generator to play each note\\n sstream = self.generator.play(sourcemap)\\n playlen = sstream.values.size\\n if 'phi' in sourcemap:\\n phi = const_or_evo(sourcemap['phi'], sstream.sampfracs) * 2 * np.pi\\n else:\\n phi = const_or_evo(self.generator.preset['phi'], sstream.sampfracs) * 2 * np.pi\\n if 'theta' in sourcemap:\\n theta = const_or_evo(sourcemap['theta'], sstream.sampfracs) * np.pi\\n else:\\n theta = const_or_evo(self.generator.preset['theta'], sstream.sampfracs) * np.pi\\n\\n # compute sample indices for truncating notes overshooting sonification length\\n trunc_note = min(playlen, lastsamp-tsamp)\\n trunc_soni = trunc_note + tsamp\\n\\n # spatialise audio by computing relative volume in each speaker\\n for i in range(Nchan):\\n panenv = self.channels.mics[i].antenna(phi,theta)\\n self.out_channels[str(i)].values[tsamp:trunc_soni] += (sstream.values*panenv)[:trunc_note]\",\n \"def generate_synth_data(n):\",\n \"def sample(self, verbose=False):\\n\\t\\tfor i in range(self.nsamp): self.subsample(verbose)\\n\\t\\treturn self.amps, self.pos, self.irads\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_samples(self, n_samples):\",\n \"def downsample_sam(self, factor):\",\n \"def _group_samples_by_channel(self):\\n samples_acquired_per_channel = len(self.all_samples_list) / self.num_channels\\n\\n #make a list with each element being a numpy array for the results from each channel\\n channel_data = []\\n for i in range(self.num_channels):\\n channel_data.append(numpy.zeros(samples_acquired_per_channel,dtype=float))\\n\\n scan_num = 0\\n channel_index = 0\\n for sample in range(len(self.all_samples_list)): #each sample in interleaved list\\n channel_data[channel_index][scan_num] = self.all_samples_list[sample]\\n if channel_index < self.num_channels-1:\\n channel_index += 1\\n else:\\n channel_index = 0\\n scan_num += 1\\n\\n if self.num_channels == 1: #if only one channel put the numpy array on the queue\\n self.result_queue.put(channel_data[0])\\n else: #if more than one channel put the list of arrays on the queue\\n self.result_queue.put(channel_data)\",\n \"def test_random_reads_chs(demo_data):\\n\\n fetches = 10\\n chs = [1,3]\\n pyeeg = pyEDF(demo_data)\\n openeeg = openEDF(demo_data)\\n openeeg.channels = chs\\n\\n #build fetch numbers of start and stop sample indices\\n starts = np.random.randint(0, 5e6, fetches)\\n stops = starts + np.random.randint(0, 5e5)\\n \\n for start, stop in zip(starts, stops):\\n arr = openeeg.read(start, stop)\\n other = pyread(pyeeg, start, stop, channels=chs)\\n assert np.allclose(arr, other)\\n\\n pyeeg.close()\\n openeeg.close()\",\n \"def sample(self):\",\n \"def produce_features(self, chip):\\n raise NotImplementedError(\\\"produce_features() not implemented\\\")\",\n \"def create_shard(dataset, num_shards):\\n input_chips, label_chips = [], []\\n for item in tqdm(dataset):\\n # not using chip_id and chip_for_display fields\\n input_chips.append(item['chip'])\\n label_chips.append(item['chip_label'])\\n\\n # debugging\\n # if len(input_chips) > 200:\\n # break\\n num_chips = len(input_chips)\\n print(f'Created {num_chips} chips.')\\n\\n items_per_shards = math.ceil(num_chips / num_shards)\\n shard_idx = []\\n for i in range(num_shards):\\n shard_idx.append(\\n (i * items_per_shards, (1 + i) * items_per_shards)\\n )\\n # print(f'Debug - shard_end_idx is {shard_idx}')\\n\\n print('Stacking imagery and label chips into shards')\\n input_chip_shards, label_chip_shards = [], []\\n for begin_idx, end_idx in shard_idx:\\n if begin_idx < num_chips:\\n input_chip_shard = input_chips[begin_idx:end_idx]\\n input_chip_shard = np.stack(input_chip_shard, axis=0)\\n print(f'dim of input chip shard is {input_chip_shard.shape}, dtype is {input_chip_shard.dtype}')\\n input_chip_shards.append(input_chip_shard)\\n\\n label_chip_shard = label_chips[begin_idx:end_idx]\\n label_chip_shard = np.stack(label_chip_shard, axis=0)\\n print(f'dim of label chip shard is {label_chip_shard.shape}, dtype is {label_chip_shard.dtype}')\\n label_chip_shards.append(label_chip_shard)\\n\\n return (input_chip_shards, label_chip_shards)\",\n \"def _choose_sample(self):\\n\\n \\t #periodically generate a new reconstruction for the purposes of sampling\",\n \"def __set_chips(self):\\n\\n # Scan filesystem\\n root_files = [root_file for root_file in os.walk(self.dataset_path)]\\n\\n # Decode truth.txt file\\n truth_files = [os.path.join(walked[0], 'truth.txt') for walked in root_files if 'truth.txt' in walked[2]]\\n if len(truth_files) == 0:\\n raise IOError(\\\"No truth file found.\\\")\\n elif len(truth_files) > 1:\\n raise IOError(\\\"Too many truth files available.\\\")\\n\\n truth_data = self.__decode_truth_file(truth_files.pop())\\n if len(truth_data) < 1:\\n raise IOError(\\\"No truth loaded\\\")\\n if self.__debug:\\n print(\\\"{} truth records loaded.\\\".format(len(truth_data)))\\n\\n # Index all image chips\\n file_paths = [[os.path.join(walked[0], wfile) for wfile in walked[2]] for walked in root_files]\\n chip_idx = dict(filter(lambda t: t is not None, map(self.__index_chip, itertools.chain(*file_paths))))\\n\\n if len(chip_idx) != len(truth_data):\\n raise IOError(\\\"Number of truth records not equal to number of chips.\\\")\\n if self.__debug:\\n print(\\\"{} image chips loaded.\\\".format(len(chip_idx)))\\n\\n # Create and store chips\\n self.chips = {meta['file']: self.__create_chip(meta, truth_data[idx]) for idx, meta in chip_idx.items()}\\n if self.__debug:\\n print(\\\"{} chip.Chips loaded.\\\".format(len(self.chips)))\",\n \"def hires_read_1chip(hdu,chipno):\\n\\n # Extract datasec from header\\n datsec = hdu[chipno].header['DATASEC']\\n detsec = hdu[chipno].header['DETSEC']\\n postpix = hdu[0].header['POSTPIX']\\n precol = hdu[0].header['PRECOL']\\n\\n x1_dat, x2_dat, y1_dat, y2_dat = np.array(parse.load_sections(datsec)).flatten()\\n x1_det, x2_det, y1_det, y2_det = np.array(parse.load_sections(detsec)).flatten()\\n\\n # This rotates the image to be increasing wavelength to the top\\n #data = np.rot90((hdu[chipno].data).T, k=2)\\n #nx=data.shape[0]\\n #ny=data.shape[1]\\n\\n # Science data\\n fullimage = hdu[chipno].data\\n data = fullimage[x1_dat:x2_dat,y1_dat:y2_dat]\\n\\n # Overscan\\n oscan = fullimage[:,y2_dat:]\\n\\n # Flip as needed\\n if x1_det > x2_det:\\n data = np.flipud(data)\\n oscan = np.flipud(oscan)\\n if y1_det > y2_det:\\n data = np.fliplr(data)\\n oscan = np.fliplr(oscan)\\n\\n # Return\\n return data, oscan\",\n \"def sample(read_sampler, n, array, res=1.0, prng = np.random.RandomState()):\\n for read in read_sampler.pull_reads(n, prng):\\n map_read(array, read, res)\",\n \"def read_sample(sample_path):\\n files = os.listdir(sample_path)\\n json_path = [f for f in files if f.endswith('_read-info.json')]\\n assert len(json_path) == 1, 'There should be exactly 1 *_read-info.json file in the sample (.smpl)'\\n # get base for sample\\n with open(os.path.join(sample_path, json_path[0]), 'r') as f:\\n sample = json.load(f)\\n # get sample info\\n info_path = [f for f in files if f.endswith('info.csv')]\\n assert len(info_path) == 1, 'There should be exactly 1 *_info.csv file in the sample (.smpl)'\\n sample['info'] = pd.read_csv(os.path.join(sample_path, info_path[0]))\\n info_path = os.path.join(sample_path, info_path[0])\\n # get individual sample\\n regex = re.compile(r'id-\\\\d*_t-\\\\d*')\\n pairs = [f for f in files if len(regex.findall(f)) > 0]\\n for str_pair in pairs:\\n pair_dir = os.path.join(sample_path, str_pair)\\n pair_dict = {}\\n # get df\\n df_path = os.path.join(pair_dir, str_pair + '_df.csv')\\n pair_dict['df'] = pd.read_csv(df_path)\\n pair_dict['df_path'] = df_path\\n pair_dict['info_path'] = info_path\\n # get tracks\\n tracks_path = os.path.join(pair_dir, str_pair + '_tracks.zarr')\\n pair_dict['tracks'] = zarr.open(tracks_path)\\n # get b_box\\n bbox_path = os.path.join(pair_dir, str_pair + '_bbox.json')\\n with open(bbox_path, 'r') as f:\\n bbox = json.load(f)\\n new_bbox = {}\\n for key in bbox.keys():\\n args = list(bbox[key])\\n new_bbox[key] = slice(*args)\\n pair_dict['b_box'] = new_bbox\\n # find out if corrs exist and read if so\\n corr_path = [f for f in os.listdir(pair_dir) if f.endswith('_corr.json')]\\n if len(corr_path) > 0:\\n with open(os.path.join(pair_dir, corr_path[0]), 'r') as f:\\n corr = json.load(f)\\n pair_dict['corr'] = corr\\n # if image exists, read\\n img_path = os.path.join(pair_dir, str_pair + '_image.zarr')\\n if os.path.exists(img_path):\\n img = zarr.open(img_path)\\n #print(img, img_path)\\n pair_dict['image'] = img\\n # if labels exist, read\\n lab_path = os.path.join(pair_dir, str_pair + '_labels.zarr')\\n if os.path.exists(lab_path):\\n lab = zarr.open(lab_path)\\n #print(lab.shape)\\n pair_dict['labels'] = lab\\n # add pair to sample\\n id_re = re.compile(r'id-\\\\d*')\\n ID = id_re.findall(str_pair)[0][3:]\\n t_re = re.compile(r't-\\\\d*')\\n t = t_re.findall(str_pair)[0][2:]\\n pair = (int(ID), int(t))\\n sample[pair] = pair_dict\\n #print(str_pair, pair)\\n #print(list(sample.keys()))\\n #print(list(sample[eval(pairs[0])].keys()))\\n return sample\",\n \"def split(filepath, nsamples):\\n start = np.cumsum([0] + list(nsamples[:-1]))\\n if filepath[-10:] == 'analog.brw':\\n filename = filepath[:-10]\\n analog = read_3brain_analog(filepath)\\n for i, (s,n) in enumerate(zip(start, nsamples)):\\n name = f\\\"{filename}_part_{i}_analog.npz\\\"\\n print(f\\\"Saving {name}\\\")\\n sampling_rate = glia.sampling_rate(filepath)\\n np.savez(name, analog=analog[s:s+n],\\n sampling_rate=sampling_rate)\\n elif filepath[-4:] == \\\".bxr\\\":\\n filename = filepath[:-4]\\n # split spike-sorted data\\n with h5py.File(filepath, 'r') as h5:\\n # shared setup for the concatenated arrays\\n sampling_rate = float(h5[\\\"3BRecInfo\\\"][\\\"3BRecVars\\\"][\\\"SamplingRate\\\"][0])\\n channel_map = h5[\\\"3BRecInfo\\\"][\\\"3BMeaStreams\\\"][\\\"Raw\\\"][\\\"Chs\\\"][()]\\n \\n # map 3brain unit num\\n # numbers typically from -4 to 9000\\n # where negative numbers appear across multiple channels\\n # and thus are presumably bad units...?\\n # positive-numbered units appear on one channel\\n unit_id_2_num = {}\\n\\n n_unit_nums = 0\\n if \\\"SpikeUnits\\\" in h5[\\\"3BResults\\\"][\\\"3BChEvents\\\"]:\\n for chunk in iter_chunks(h5['3BResults/3BChEvents/SpikeUnits'], 10000):\\n n_unit_nums = max(n_unit_nums, chunk.max())\\n \\n unit_map = {}\\n channel_unit_count = {}\\n\\n\\n # operate on each of the concatenated arrays, one at a time\\n for i, (s,n) in enumerate(zip(start, nsamples)):\\n startTime = s / sampling_rate\\n first_idx = None\\n for chunk in iter_chunks(h5['3BResults/3BChEvents/SpikeTimes'], 10000):\\n valid_idxs = np.argwhere(h5[\\\"3BResults/3BChEvents/SpikeTimes\\\"] > s)\\n if len(valid_idxs) > 0:\\n first_idx = valid_idxs[0][0]\\n break\\n assert not first_idx is None\\n print(f\\\"identified start idx of {first_idx}.\\\")\\n\\n # for simplicity, we just iterate again, could have faster implementation\\n last_idx = len(h5['3BResults/3BChEvents/SpikeTimes'])\\n chunk_size = 10000\\n for j, chunk in enumerate(iter_chunks(h5['3BResults/3BChEvents/SpikeTimes'], chunk_size)):\\n invalid_idxs = np.argwhere(chunk > s + n)\\n if len(invalid_idxs) > 0:\\n last_idx = invalid_idxs[0][0] + j*chunk_size\\n break\\n print(f\\\"identified stop idx of {last_idx}.\\\")\\n \\n spike_channel_ids = h5[\\\"3BResults\\\"][\\\"3BChEvents\\\"][\\\"SpikeChIDs\\\"][first_idx:last_idx]\\n spike_unit_ids = h5[\\\"3BResults\\\"][\\\"3BChEvents\\\"][\\\"SpikeUnits\\\"][first_idx:last_idx]\\n # poorly named; time is in units of 1/sampling_rate\\n # aka sample number\\n # subtract to adjust start time\\n spike_times = h5[\\\"3BResults\\\"][\\\"3BChEvents\\\"][\\\"SpikeTimes\\\"][first_idx:last_idx] - s\\n \\n\\n \\n csv_name = f'{filename}_part_{i}_spikes.csv'\\n spikes = zip(spike_channel_ids, spike_unit_ids, spike_times)\\n tot_spikes = spike_times.shape[0]\\n print(f\\\"creating {csv_name} ...\\\")\\n with open(csv_name, 'w', newline='') as csvfile:\\n fieldnames = ['channel_i', 'channel_j', 'unit', \\\"spike_time\\\"]\\n writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\\n\\n writer.writeheader()\\n for channel, unit_id, spike_time in tqdm(spikes,\\n total=tot_spikes):\\n c = channel_map[channel]\\n # convert to tuple\\n # account for 1-indexing\\n c = (c[0]-1,c[1]-1)\\n \\n # count num units on channel\\n # first check if we've seen this channel before\\n if not c in channel_unit_count:\\n # if not, initialize channel_unit_count for the channel\\n channel_unit_count[c] = 1\\n unit_num = 0\\n # add unit\\n unit_id_2_num[unit_id] = unit_num\\n else:\\n \\n # then check if we've seen this unit before\\n if not unit_id in unit_id_2_num:\\n # if not, assign unit_num for this new unit\\n unit_num = channel_unit_count[c]\\n unit_id_2_num[unit_id] = unit_num\\n channel_unit_count[c] += 1\\n else:\\n # otherwise, look it up\\n unit_num = unit_id_2_num[unit_id]\\n \\n \\n t = spike_time / sampling_rate\\n writer.writerow({\\\"channel_i\\\": c[0],\\n \\\"channel_j\\\": c[1],\\n \\\"unit\\\": unit_num,\\n \\\"spike_time\\\": t})\\n \\n np.save(f\\\"{filename}_channel_map.npy\\\", channel_map)\",\n \"def _compute_samples(self, samples):\\n return samples\",\n \"def features_combine():\\n\\n\\n\\t# PROCESSING AUDIO\",\n \"def chip_image1(img, chip_size=(300, 300)):\\n width, height, _ = img.shape\\n wn, hn = chip_size\\n images = np.zeros((int(width / wn) * int(height / hn), wn, hn, 3))\\n k = 0\\n for i in tqdm(range(int(width / wn))):\\n for j in range(int(height / hn)):\\n chip = img[wn * i:wn * (i + 1), hn * j:hn * (j + 1), :3]\\n images[k] = chip\\n\\n k = k + 1\\n\\n return images.astype(np.uint8)\",\n \"def magic_sample(self, ys):\\n\\n #for each non-zero element in y\\n #we want to multiply the initial state by HGate(i) SGate(i) HGate(i)\\n #this turns out to be equivalent to multiplying the whole final state by\\n #U H_k S_k H_k U^\\\\dagger\\n #but H_k S_k H_k = e^{i\\\\pi/4} \\\\frac{1}{\\\\sqrt{2}} (I -i X_k)\\n #so now we evolve identity forward by U (trivial)\\n #and evolve X_k forward by U (using the AGState)\\n #then we have to send the resulting Pauli through UC and UH\\n #giving a third Pauli\\n #then the state is of the form (we^{i\\\\pi/4}) UC UH (I + i^d P)/sqrt(2) |s>\\n #then we apply Bravyi et al's prop. 4 to turn this into a new ch form\\n \\n\\n chCopy = deepcopy(self.chState) #we update this copy as we go\\n\\n for i, y in enumerate(ys):\\n if y:\\n #we want to know what U_c^\\\\dagger U X_i U^\\\\dagger U_c is\\n #firstly we use the A-G info\\n # U X_i U^\\\\dagger is the i'th destabiliser\\n x = self.agState.x[self.n+i]\\n z = self.agState.z[self.n+i]\\n r = self.agState.r[self.n+i]\\n\\n #print(x,z,r)\\n x_col = np.array([x]).T\\n z_col = np.array([z]).T\\n \\n #now we apply U_c to this using the CH-form info\\n x_mat = chCopy.F * x_col\\n z_mat = (chCopy.M * x_col + chCopy.G*z_col) % np.uint8(2)\\n r = (r + util.sort_pauli_string(x_mat, z_mat)) % np.uint8(2)\\n\\n u = (x @ chCopy.F) % np.uint8(2)\\n h = (x @ chCopy.M + z @ chCopy.G) % np.uint8(2)\\n\\n g = (x @ (z + chCopy.g)) % np.uint8(4)\\n\\n #now U_c^dag U X_i U^dag U_C = (-1)^r i^g prod_j Z_j^{h_j} X_j^{u_j}\\n #we want to conjugate this by U_H\\n #everywhere chCopy.v == 1 we flip a z to an x and an x to a z\\n #everywhere chCopy.v == 1 and u == 1 and h == 1 we need to swap the order of our x and z so we get a minus sign\\n\\n u2 = u*(np.uint8(1) ^ chCopy.v) ^ (h*chCopy.v)\\n h2 = (u*chCopy.v) ^ (h*(np.uint8(1) ^ chCopy.v))\\n\\n r = (r + (u*h*chCopy.v).sum()) % np.uint8(2)\\n \\n \\n #now U_H^dag U_c^dag U X_i U^dag U_C U_H = (-1)^r i^g prod_j Z_j^{h2_j} X_j^{u2_j}\\n\\n t = u2 ^ chCopy.s\\n r = (r + h2 @ t) % np.uint8(2)\\n\\n #now we have w UC UH |s> = w (-1)^r (i)^g UC UH |t>\\n\\n if all(t == chCopy.s):\\n chCopy.w *= np.exp(1j*np.pi/4) * (1 + (1j)**(g+2*r -1) )/ np.sqrt(2)\\n else:\\n phase, VCList, v, s = util.desuperpositionise(chCopy.s, t, (g+2*r -1)%np.uint8(4), chCopy.v)\\n\\n chCopy.w *= phase*np.exp(1j*np.pi/4)/np.sqrt(2)\\n chCopy.v = v\\n chCopy.s = s\\n\\n for gate in VCList:\\n gate.rightMultiplyC(chCopy)\\n \\n return chCopy\",\n \"def init_devices(self):\\n self.hp_nb = int(self.rs_nb* self.hp_proportion/(1- self.hp_proportion))\\n self.defense_cost = self.hp_nb * self.hp_unit_cost\\n rs_devices = [True for i in range(self.rs_nb)] #rs --> True\\n hp_devices = [False for i in range(self.hp_nb)] #hp --> False\\n self.devices = rs_devices + hp_devices\\n shuffle(self.devices)\",\n \"def next_batch(self):\\n sp, noise, mix = super().next_batch()\\n\\n if sp.shape != noise.shape or sp.shape != mix.shape:\\n raise Exception(\\\"ERROR: sp.shape != noise.shape or sp.shape != mix.shape\\\")\\n\\n batch_size, frames, bins = mix.shape\\n\\n mix_feat = chimera_preprocess(mix)\\n mix_clean = np.abs(mix)\\n\\n # Get dominant spectra indexes, create one-hot outputs\\n M = np.zeros(mix.shape + (2,), dtype=np.float32)\\n M[:, :, :, 0] = (abs(sp) >= abs(noise))\\n M[:, :, :, 1] = (abs(sp) < abs(noise))\\n\\n M_clean = np.zeros(mix.shape + (2,), dtype=np.float32)\\n M_clean[:, :, :, 0] = np.abs(sp)\\n M_clean[:, :, :, 1] = np.abs(noise)\\n\\n return mix_feat, mix_clean, M, M_clean\",\n \"def read_and_display_data(hat, samples_per_channel, num_channels): \\n \\n # Read all of the available samples (up to the size of the read_buffer which\\n # is specified by the user_buffer_size). Since the read_request_size is set\\n # to -1 (READ_ALL_AVAILABLE), this function returns immediately with\\n # whatever samples are available (up to user_buffer_size) and the timeout\\n # parameter is ignored.\\n total_samples_read = 0\\n read_request_size = READ_ALL_AVAILABLE\\n completeFlag = 0 \\n timeout = 5.0\\n \\n # file switch: w = Write to a file\\n # file switch: w+ = Write to a file, if it doesn't exist create it\\n # file switch: a = Append to a file\\n # file switch: a+ = Append to a file, if is doesn't exist create it.\\n # file switch: x = will create a file, returns an error if the file exist\\n \\n\\n # If the scan starts, create a file name based upon current date and time.\\n # Retrieve the Current Working Directory and generate the full path \\n # to where to write the collected data as a .csv file. Open the file \\n # begin writing the data to the file. When done, close the file.\\n \\n try:\\n if os.path.exists(basepath):\\n if not (os.path.exists(mypath)):\\n os.mkdir(mypath)\\n else:\\n os.mkdir(basepath)\\n os.chdir(basepath)\\n os.mkdir(mypath)\\n except OSError as exc:\\n raise\\n \\n os.chdir(mypath)\\n fileDateTime = datetime.strftime(datetime.now(), \\\"(%m_%d_%Y)-(%H-%M-%S)\\\")\\n #filePath = mypath + \\\"/\\\" + DAQ_NAME + \\\"_\\\" + fileName + \\\".csv\\\"\\n filePath = mypath + \\\"/\\\" + DAQ_NAME + \\\"_\\\" + fileDateTime + \\\".csv\\\"\\n csvfile = open(filePath, \\\"w+\\\")\\n csvwriter = csv.writer(csvfile) \\n \\n # Recording LED\\n GPIO.setmode(GPIO.BCM)\\n GPIO.setup(RECORDING_LED, GPIO.OUT, initial=GPIO.LOW)\\n GPIO.output(RECORDING_LED,GPIO.HIGH)\\n \\n while total_samples_read < samples_per_channel:\\n read_result = hat.a_in_scan_read(read_request_size, timeout)\\n\\n # Check for an overrun error\\n if read_result.hardware_overrun:\\n print('\\\\n\\\\nHardware overrun\\\\n')\\n break\\n elif read_result.buffer_overrun:\\n print('\\\\n\\\\nBuffer overrun\\\\n')\\n break\\n elif not (read_result.running and completeFlag == 0):\\n completeFlag = 1\\n print('\\\\n (2) Recording Completed - Buffer Draining')\\n\\n samples_read_per_channel = int(len(read_result.data) / num_channels)\\n total_samples_read += samples_read_per_channel\\n \\n totalSamples = len(read_result.data) \\n\\n if samples_read_per_channel > 0:\\n index = samples_read_per_channel * num_channels - num_channels\\n \\n new_index = 0\\n myArray=[] #create an empty array\\n for i in range(0, totalSamples, num_channels):\\n myArray.append([]) #add a row to the array (COLUMN)\\n for j in range(num_channels):\\n\\t\\t\\t\\t\\t#append a num_channels of data to the array (ROW)\\n myArray[new_index].append(read_result.data[i + j]) \\n new_index+=1\\n\\n csvwriter.writerows(myArray) #Write the array to file\\n csvfile.flush\\n\\n # Cleanup\\n csvfile.close() \\n print('\\\\n (3) Buffer Drained - Data Saved to CSV File\\\\n')\\n GPIO.cleanup()\\n GPIO.setmode(GPIO.BCM)\\n \\n # Complete LED\\n GPIO.setup(COMPLETE_LED, GPIO.OUT, initial=GPIO.LOW)\\n GPIO.output(COMPLETE_LED,GPIO.HIGH)\\n time.sleep(5)\\n GPIO.cleanup()\\n hat.a_in_scan_cleanup()\\n global CMD_RECEIVED\\n CMD_RECEIVED = 1\\n \\n # Restarts script to prepare for another recording\\n main()\",\n \"def generate_sample_sheet(self):\\n pool = self.pool\\n bcl2fastq_sample_ids = []\\n i7_names = []\\n i7_sequences = []\\n i5_names = []\\n i5_sequences = []\\n wells = []\\n plate = pool.container.external_id\\n sample_ids = []\\n sequencer_type = self.sequencer.equipment_type\\n\\n for component in pool.components:\\n lp_composition = component['composition']\\n # Get the well information\\n wells.append(lp_composition.container.well_id)\\n # Get the i7 index information\\n i7_comp = lp_composition.i7_composition.primer_set_composition\\n i7_names.append(i7_comp.external_id)\\n i7_sequences.append(i7_comp.barcode)\\n # Get the i5 index information\\n i5_comp = lp_composition.i5_composition.primer_set_composition\\n i5_names.append(i5_comp.external_id)\\n i5_sequences.append(i5_comp.barcode)\\n # Get the sample id\\n sample_id = lp_composition.normalized_gdna_composition.\\\\\\n gdna_composition.sample_composition.content\\n sample_ids.append(sample_id)\\n\\n # Transform te sample ids to be bcl2fastq-compatible\\n bcl2fastq_sample_ids = [\\n SequencingProcess._bcl_scrub_name(sid) for sid in sample_ids]\\n # Reverse the i5 sequences if needed based on the sequencer\\n i5_sequences = SequencingProcess._sequencer_i5_index(\\n sequencer_type, i5_sequences)\\n\\n data = SequencingProcess._format_sample_sheet_data(\\n bcl2fastq_sample_ids, i7_names, i7_sequences, i5_names,\\n i5_sequences, wells=wells, sample_plate=plate,\\n description=sample_ids, sample_proj=self.run_name,\\n lanes=self.lanes, sep=',')\\n\\n contacts = {c.name: c.email for c in self.contacts}\\n pi = self.principal_investigator\\n principal_investigator = {pi.name: pi.email}\\n sample_sheet_dict = {\\n 'comments': SequencingProcess._format_sample_sheet_comments(\\n principal_investigator=principal_investigator,\\n contacts=contacts),\\n 'IEMFileVersion': '4',\\n 'Investigator Name': pi.name,\\n 'Experiment Name': self.experiment,\\n 'Date': str(self.date),\\n 'Workflow': 'GenerateFASTQ',\\n 'Application': 'FASTQ Only',\\n 'Assay': self.assay,\\n 'Description': '',\\n 'Chemistry': 'Default',\\n 'read1': self.fwd_cycles,\\n 'read2': self.rev_cycles,\\n 'ReverseComplement': '0',\\n 'data': data}\\n return SequencingProcess._format_sample_sheet(sample_sheet_dict)\",\n \"def hand_samples(data,lfs,rfs,start_frame,cap,show=False):\\n data['lhkpss'] = hand.translate_hand_kps(data['lhkpss'],data['kpss'],7);\\n data['rhkpss'] = hand.translate_hand_kps(data['rhkpss'],data['kpss'],4);\\n row1 = [];\\n row2 = [];\\n for f in lfs:\\n cap.set(cv2.CAP_PROP_POS_FRAMES,start_frame+f);\\n _,frame = cap.read();\\n data['crop'] = ut.crop(frame,256,320);\\n data['i'] = f;\\n row1.append(draw_lh_lines(data)[105:-65,105:-65]);\\n for f in rfs:\\n cap.set(cv2.CAP_PROP_POS_FRAMES,start_frame+f);\\n _,frame = cap.read();\\n data['crop'] = ut.crop(frame,256,320);\\n data['i'] = f;\\n row2.append(draw_rh_lines(data)[65:-105,65:-105]);\\n row1 = np.concatenate(row1,axis=1);\\n row2 = np.concatenate(row2,axis=1);\\n grid = np.concatenate([row1,row2]);\\n if show:\\n ut.show(grid);\\n return grid;\",\n \"def samples_sorted():\\n\\n import glob\\n cars_original = glob.glob(\\\"./vehicles/*/*.png\\\")\\n # The following are duplicated:\\n cars_KITTI = glob.glob(\\\"./vehicles/KITTI_extracted/*.png\\\")\\n cars_GTI_Right = glob.glob(\\\"./vehicles/GTI_Right/*.png\\\")\\n cars_GTI_Left = glob.glob(\\\"./vehicles/GTI_Left/*.png\\\")\\n cars = cars_original + cars_KITTI + cars_GTI_Left + cars_GTI_Right\\n # The above introduces duplication of samples, causing bleeding of training samples into validation\\n np.random.shuffle(cars) # side effect return None\\n cars_to_be_augmented = cars_GTI_Left + cars_GTI_Right\\n np.random.shuffle(cars_to_be_augmented)\\n num_cars = len(cars) + len(cars_to_be_augmented)\\n\\n non_cars_original = glob.glob(\\\"./non-vehicles/*/*.png\\\")\\n # The following are duplicated:\\n non_cars_Extras = glob.glob(\\\"./non-vehicles/Extras/*.png\\\")\\n noncars = non_cars_original + non_cars_Extras + non_cars_Extras\\n # The above introduces duplication of samples, causing bleeding of training samples into validation\\n np.random.shuffle(noncars) # side effect return None\\n num_noncars = len(noncars)\\n return cars, noncars, cars_to_be_augmented, num_cars, num_noncars\",\n \"def create_samples(self):\\n for s_id in range(len(self.data[\\\"sample\\\"])):\\n self.samples.add(Sample(s_id, [self.data[key][s_id] for key in self.data.keys() if key not in WRONG_KEYS],\\n self.data[\\\"label\\\"][s_id]))\",\n \"def sort_reads(self): \\n if not self.sampling:\\n self.convert_to_array()\\n self.reads = self.reads[self.reads[:,0].argsort()]\",\n \"def sample(self, size=1):\\n pass\",\n \"def __init__(self, starting_point=-1):\\n self.i_read = starting_point\\n self.data = [['fake_chip_id', 'fake_version'],\\n [96, 110, 203, 104, 50, 0, 29, 145, 59, 215, 208, 11,\\n 232, 38, 42, 255, 249, 255, 172, 38, 10, 216, 189, 16],\\n [75],\\n [129, 1, 0, 16, 44, 3, 30],\\n [76, 60, 128, 129, 49, 128, 94, 120]]\",\n \"def _init_sample(self):\\n self.timestamps = np.zeros(5)\\n self.data = np.zeros((5, 12))\",\n \"def data_sample(CI, CC, thermal, calibration, health, driver_monitor, gps_location,\\n poller, cal_status, cal_perc, overtemp, free_space, low_battery,\\n driver_status, geofence, state, mismatch_counter, params):\\n\\n # Update carstate from CAN and create events\\n CS = CI.update(CC)\\n events = list(CS.events)\\n enabled = isEnabled(state)\\n\\n # Receive from sockets\\n td = None\\n cal = None\\n hh = None\\n dm = None\\n gps = None\\n\\n for socket, event in poller.poll(0):\\n if socket is thermal:\\n td = messaging.recv_one(socket)\\n elif socket is calibration:\\n cal = messaging.recv_one(socket)\\n elif socket is health:\\n hh = messaging.recv_one(socket)\\n elif socket is driver_monitor:\\n dm = messaging.recv_one(socket)\\n elif socket is gps_location:\\n gps = messaging.recv_one(socket)\\n\\n if td is not None:\\n overtemp = td.thermal.thermalStatus >= ThermalStatus.red\\n free_space = td.thermal.freeSpace < 0.15 # under 15% of space free no enable allowed\\n low_battery = td.thermal.batteryPercent < 1 # at zero percent battery, OP should not be allowed\\n\\n # Create events for battery, temperature and disk space\\n if low_battery:\\n events.append(create_event('lowBattery', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\\n if overtemp:\\n events.append(create_event('overheat', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\\n if free_space:\\n events.append(create_event('outOfSpace', [ET.NO_ENTRY]))\\n\\n # Handle calibration\\n if cal is not None:\\n cal_status = cal.liveCalibration.calStatus\\n cal_perc = cal.liveCalibration.calPerc\\n\\n if cal_status != Calibration.CALIBRATED:\\n if cal_status == Calibration.UNCALIBRATED:\\n events.append(create_event('calibrationIncomplete', [ET.NO_ENTRY, ET.SOFT_DISABLE, ET.PERMANENT]))\\n else:\\n events.append(create_event('calibrationInvalid', [ET.NO_ENTRY, ET.SOFT_DISABLE]))\\n\\n # When the panda and controlsd do not agree on controls_allowed\\n # we want to disengage openpilot. However the status from the panda goes through\\n # another socket than the CAN messages, therefore one can arrive earlier than the other.\\n # Therefore we allow a mismatch for two samples, then we trigger the disengagement.\\n if not enabled:\\n mismatch_counter = 0\\n\\n if hh is not None:\\n controls_allowed = hh.health.controlsAllowed\\n if not controls_allowed and enabled:\\n mismatch_counter += 1\\n if mismatch_counter >= 2:\\n events.append(create_event('controlsMismatch', [ET.IMMEDIATE_DISABLE]))\\n\\n # Driver monitoring\\n if dm is not None:\\n driver_status.get_pose(dm.driverMonitoring, params)\\n\\n # Geofence\\n if geofence is not None and gps is not None:\\n geofence.update_geofence_status(gps.gpsLocationExternal, params)\\n if geofence is not None and not geofence.in_geofence:\\n events.append(create_event('geofence', [ET.NO_ENTRY, ET.WARNING]))\\n\\n return CS, events, cal_status, cal_perc, overtemp, free_space, low_battery, mismatch_counter\",\n \"def _sample(self, rnn_output, temperature):\\n pass\",\n \"def process_sample(self, ch, method, properties, body):\\n\\n # data inside a dictionary\\n # {'amplitude':[1.3,4.4,5...],\\n # 'angle': [0.04,0.1,...]}\\n sample_dict = self.deserialize_vtt_60_processed(body)\\n\\n with open('sample_test_run.txt', 'a') as f:\\n x_arrstr = np.char.mod('%d', sample_dict['amplitude'])\\n\\n # x_arrstr -> should be 2d array \\\"frame\\\".\\n raw_data = \\\",\\\".join(x_arrstr.flatten())\\n f.write(raw_data)\\n f.write('\\\\n')\\n\\n arr = np.array(sample_dict['amplitude'])\\n\\n frame = np.reshape(arr, (180,110))\\n frame_transposed_flipped = np.flip(np.transpose(frame))\\n frame_transposed_flipped = np.flip(np.transpose(frame))\\n details_removed = frame_transposed_flipped\\n details_removed = np.clip(frame_transposed_flipped, a_min=frame_transposed_flipped.max() - 15, a_max=None)\\n self.i = self.i + 1\\n if self.i % 10 == 0:\\n b = sum(pd.DataFrame(frame).max().diff() / pd.DataFrame(frame).max() > 0.13)\\n self.report_people(b)\\n\\n\\n if body is None or sample_dict is None:\\n print('Stream stopped.')\\n return\\n if self.samples_in_total % self.fps == 0:\\n endTime = time.time()\\n print('FPS: {:.1f}'.format(self.fps/(endTime - self.startTime)))\\n self.startTime = endTime\\n \\n # your code here\\n amplitude = sample_dict['amplitude']\\n amplitude = np.reshape(amplitude,(180,110))\\n amplitude = np.where(amplitude>130,130,amplitude)\\n amplitude = np.uint8(255*amplitude/130)\\n out = cv2.cvtColor(amplitude,cv2.COLOR_GRAY2BGR)\\n out = cv2.applyColorMap(out,cv2.COLORMAP_MAGMA)\\n cv2.imshow('junction',out)\\n cv2.waitKey(10)\",\n \"def collater(self, samples):\\r\\n raise NotImplementedError\",\n \"def __init__(self, samples):\\n self.samples = samples\",\n \"def __init__(self):\\n ChipData.ChipData.__init__(self)\",\n \"def read_cine_protocol(series_dicom_header):\\n assert len(series_dicom_header.StudyInstanceUID.unique()) == 1, 'Trying to read dicoms from multiple studies!'\\n assert len(series_dicom_header.SpacingBetweenSlices.unique()) == 1\\n\\n SpacingBetweenSlices = list(series_dicom_header.SpacingBetweenSlices)[0]\\n SliceLocations = series_dicom_header.SliceLocation.unique()\\n number_of_slices = len(SliceLocations) \\n\\n phases_per_slice = [len(series_dicom_header[series_dicom_header.SliceLocation==SliceLocation].InstanceNumber) \\n for SliceLocation in series_dicom_header.SliceLocation.unique()]\\n number_of_phases = phases_per_slice[0]\\n\\n if len(np.unique(phases_per_slice)) != 1:\\n warnings.warn('Number of phases is variable across slice locations! Could be real or error, check!.')\\n return None\\n \\n print('Found cine study with (number_of_slices, number_of_phases)', number_of_slices, number_of_phases)\\n pixel_array = pydicom.read_file(series_dicom_header.iloc[0].FileName).pixel_array\\n \\n sax_4D = np.zeros((pixel_array.shape +(number_of_slices, number_of_phases)), dtype=pixel_array.dtype)\\n \\n dicom_4D_paths = {}\\n for SliceIndex, SliceLocation in enumerate(sorted(SliceLocations)):\\n slice_header = series_dicom_header[series_dicom_header.SliceLocation==SliceLocation]\\n dicom_4D_paths[SliceIndex] = []\\n for InstanceIndex, InstanceNumber in enumerate(sorted(slice_header.InstanceNumber)):\\n DicomFileName = slice_header[slice_header.InstanceNumber==InstanceNumber].FileName.item()\\n dicom = pydicom.read_file(DicomFileName)\\n sax_4D[:,:,SliceIndex,InstanceIndex] += dicom.pixel_array\\n\\n dicom_4D_paths[SliceIndex] += [DicomFileName]\\n\\n affine = read_affine(series_dicom_header.iloc[series_dicom_header.SliceLocation.argmin()])\\n\\n sax_4D = nib.Nifti1Image(sax_4D, affine=affine), \\n sax_4D.SpacingBetweenSlices = SpacingBetweenSlices\\n\\n return sax_4D, dicom_4D_paths\",\n \"def sample(self):\\n logger.info(\\\"%s: collect sensor data\\\", self.__class__.__name__)\\n samples = []\\n self._fetch_data(samples)\\n return samples\",\n \"def __init__(self, array_size, readnoise, dark_current, gain):\\n \\n self.array_size = array_size\\n self.readnoise = readnoise\\n self.gain = gain\\n self.dark_current = dark_current\\n\\n # Here are a bunch of default values setup.\\n\\n # Integration time in seconds\\n self.itime = 1.0\\n\\n # Coadds\\n self.coadds = 1\\n\\n # Fowler Samples for multi-CDS. This is the number of reads\\n # in the beginning and repeated at the end.\\n self.fowler = 1\\n\\n # Pixel Scale (arcsec / pixel)\\n self.scale = 0.1 \\n\\n return\",\n \"def collect(self):\\n self.prev_position = {'lefthand':kinect.get_coord('lefthand'), \\n 'righthand':kinect.get_coord('righthand')}\\n \\n while True:\\n for hand in 'lefthand','righthand':\\n position = kinect.get_coord(hand)\\n displacement = vector.Subtract(position, self.prev_position[hand])\\n acceleration = vector.Distance(displacement, self.prev_displacement[hand])\\n self.prev_position[hand] = position\\n self.prev_displacement[hand] = displacement\\n # We square the acceleration so the variance is exaggerated\\n self.accelerations[hand].append(acceleration**2) \\n \\n # Limit to latest self.sample_limit samples\\n self.accelerations[hand] = self.accelerations[hand][-self.sample_limit:] \\n self.velocities[hand].append(vector.Magnitude(displacement))\\n self.velocities[hand] = self.velocities[hand][-self.sample_limit:]\\n time.sleep(self.rate)\",\n \"def _read_bu_wig(self, handle, sequence_name):\\n self.chromosomes[sequence_name] = () \\n for line in handle:\\n position, total, reverse, forward = line.rstrip(\\\"\\\\r\\\\n\\\").split()\\n self.coverage[(sequence_name, position)] = (int(reverse), int(forward))\",\n \"def next_sample(self):\\n if self.cur >= len(self.seq):\\n raise StopIteration\\n idx = self.seq[self.cur]\\n self.cur += 1\\n s = self.imgrec.read_idx(idx)\\n header, img = recordio.unpack(s)\\n img = mx.image.imdecode(img).asnumpy()\\n hlabel = np.array(header.label).reshape( (self.num_classes,2) )\\n if not config.label_xfirst:\\n hlabel = hlabel[:,::-1] #convert to X/W first\\n annot = {'scale': config.base_scale}\\n\\n #ul = np.array( (50000,50000), dtype=np.int32)\\n #br = np.array( (0,0), dtype=np.int32)\\n #for i in range(hlabel.shape[0]):\\n # h = int(hlabel[i][0])\\n # w = int(hlabel[i][1])\\n # key = np.array((h,w))\\n # ul = np.minimum(key, ul)\\n # br = np.maximum(key, br)\\n\\n return img, hlabel, annot\",\n \"def add_read(self, new_read): \\n if self.sampling:\\n self.convert_to_list()\\n self.reads.append(new_read)\\n self.total+=1\",\n \"def rank_chanels():\\r\\n \\r\\n all_paths = [['data_bci\\\\\\\\row_data\\\\\\\\subject1\\\\\\\\'], ['data_bci\\\\\\\\row_data\\\\\\\\subject2\\\\\\\\'],['data_bci\\\\\\\\row_data\\\\\\\\subject3\\\\\\\\']]\\r\\n\\r\\n train_subjects = ['01']\\r\\n test_subject = '02'\\r\\n freq = 512\\r\\n\\r\\n cutoff_beggining = 0\\r\\n columns_to_read = ['Fp1', 'AF3' ,'F7', 'F3', 'FC1', 'FC5', 'T7', 'C3', 'CP1', 'CP5',\\r\\n 'P7', 'P3', 'Pz', 'PO3', 'O1', 'Oz', 'O2', 'PO4', 'P4', 'P8', 'CP6',\\r\\n 'CP2', 'C4', 'T8', 'FC6', 'FC2', 'F4', 'F8', 'AF4', 'Fp2', 'Fz', 'Cz','class']\\r\\n seq_len = 0\\r\\n cut_step = 0\\r\\n num_perseg = freq\\r\\n num_overlap = int(num_perseg/2)\\r\\n min_freq=8\\r\\n max_freq=45\\r\\n k = 3\\r\\n\\r\\n First_iter = True\\r\\n for path in all_paths:\\r\\n train_full_data, train_full_data_filtered, train_full_anots, test_full_data, test_sliced_full_filtered, test_full_annoations = read_filter(path, train_subjects,test_subject, columns_to_read, cutoff_beggining, seq_len, cut_step)\\r\\n\\r\\n psd_signals = eval_psd_not_modulated(train_full_data, num_perseg, num_overlap, freq, min_freq, max_freq) \\r\\n chanels_acc = iterate_over_chanels(psd_signals, train_full_anots, k)\\r\\n if First_iter:\\r\\n accuracy = chanels_acc\\r\\n First_iter = False\\r\\n else:\\r\\n accuracy += chanels_acc\\r\\n accuracy = accuracy/len(all_paths)\\r\\n sorted_indexies = np.argsort(accuracy)[::-1]\\r\\n\\r\\n\\r\\n #indexis_above_treshohld = [idx for idx in sorted_indexies if accuracy[idx]> min_accary]\\r\\n return sorted_indexies\",\n \"def __call__(self, samples_number):\\n self.sampler.sample(samples_number)\",\n \"def Read_Encoders(self):\\n max_diff = 100\\n while max_diff > 1:\\n max_diff = 0\\n time.sleep(0.2)\\n for i in range(3):\\n last_read_pos = self.read_pos[i]\\n value = self.fd_channel[i].read(3)+b'\\\\x00' \\n # read the 24 bit register (3 bytes) and add a fourth byte \\n # to make it an integer.\\n signed_value = struct.unpack(\\\"=I\\\", value)[0] \\n # Convert byte string to int\\n if signed_value > 2**23:\\n signed_value = signed_value - 2**24\\n self.read_pos[i] = signed_value\\n max_diff = max(max_diff, abs(last_read_pos - self.read_pos[i]))\\n return\",\n \"def __init__(self):\\n self.ser = serial.Serial('/dev/ttyUSB3',9600)\\n collect_readings = False\\n self.colours = []\\n self.max_readings = 50 #maximum number of readings to use\",\n \"def test_sample(system_generator):\\n\\n name, test = system_generator()\\n print(name)\\n\\n w_F, w_R, N_k = test.sample([10, 8], mode=\\\"wFwR\\\")\\n w_F, w_R, N_k = test.sample([1, 1], mode=\\\"wFwR\\\")\\n w_F, w_R, N_k = test.sample([10, 0], mode=\\\"wFwR\\\")\\n w_F, w_R, N_k = test.sample([0, 5], mode=\\\"wFwR\\\")\",\n \"def new_sample(self):\\n\\n self.u_seq.append([])\\n self.r_exp.append(0)\",\n \"def collect_samples(self):\\n self.__running = True\\n with open(self.__filename, 'a') as output:\\n next_sample_time = time.time()\\n while self.__running:\\n sensor_name = self.__sensor.get_sensor_type_name()\\n sensor_id = self.__sensor.get_sensor_id()\\n data = self.__sensor.retrieve_data_string() \\n if DEBUG:\\n print('data: \\\"{}\\\"'.format(data),\\n file = sys.stderr, flush=True)\\n when = datetime.datetime.now(datetime.timezone.utc).isoformat()\\n result = OUTPUT_FORMAT.format(when,\\n sensor_name, \\n sensor_id, \\n data)\\n output.write(result)\\n output.flush()\\n \\n next_sample_time = next_sample_time + self.__interval\\n delay_time = next_sample_time - time.time()\\n if DEBUG:\\n print('delay_time = {}'.format(delay_time),\\n file=sys.stderr, flush=True)\\n \\n if 0 < delay_time: # don't sleep if already next sample time\\n time.sleep(delay_time)\",\n \"def _read(self):\\n\\t\\tself._infoMuscles = []\\n\\t\\tself._infoCommonCellsInMuscles = []\\n\\t\\tself._infoSpecialCells = []\\n\\t\\tself._infoCommonMuscleConnections = []\\n\\t\\tself._infoInterMuscSensorimotorConnections = {}\\n\\t\\tself._infoSpecialConnections = []\\n\\t\\tif rank==0:\\n\\t\\t\\tsection = None\\n\\t\\t\\tsensorimotorConnections = None\\n\\t\\t\\tsensorimotorMatrix = None\\n\\t\\t\\tfor line in open(\\\"../nnStructures/\\\"+self._inputFile,\\\"r\\\"):\\n\\t\\t\\t\\tif line[0] == \\\"#\\\" or line[0] == \\\"\\\\n\\\": continue\\n\\t\\t\\t\\telif line[0] == \\\"@\\\": section = float(line[1])\\n\\t\\t\\t\\telif section == 1: self._infoMuscles.append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 2: self._infoCommonCellsInMuscles.append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 3: self._infoSpecialCells.append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 4: self._infoCommonMuscleConnections.append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 5:\\n\\t\\t\\t\\t\\tif line[0] == \\\"+\\\":\\n\\t\\t\\t\\t\\t\\tdictName = line[1:].strip(\\\"\\\\n\\\")\\n\\t\\t\\t\\t\\t\\tself._infoInterMuscSensorimotorConnections[dictName] = {}\\n\\t\\t\\t\\t\\t\\tsensorimotorConnections = False\\n\\t\\t\\t\\t\\t\\tsensorimotorMatrix = False\\n\\t\\t\\t\\t\\telif \\\"Connections\\\" in line:\\n\\t\\t\\t\\t\\t\\t sensorimotorConnections = True\\n\\t\\t\\t\\t\\t\\t self._infoInterMuscSensorimotorConnections[dictName][\\\"connections\\\"]=[]\\n\\t\\t\\t\\t\\telif \\\"WeightsMatrix\\\" in line:\\n\\t\\t\\t\\t\\t\\t sensorimotorConnections = False\\n\\t\\t\\t\\t\\t\\t sensorimotorMatrix = True\\n\\t\\t\\t\\t\\t\\t self._infoInterMuscSensorimotorConnections[dictName][\\\"matrix\\\"]=[]\\n\\t\\t\\t\\t\\telif sensorimotorConnections:\\n\\t\\t\\t\\t\\t\\tself._infoInterMuscSensorimotorConnections[dictName][\\\"connections\\\"].append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\t\\telif sensorimotorMatrix:\\n\\t\\t\\t\\t\\t\\tself._infoInterMuscSensorimotorConnections[dictName][\\\"matrix\\\"].append(line.strip(\\\"\\\\n\\\").split())\\n\\t\\t\\t\\telif section == 6: self._infoSpecialConnections.append(line.strip(\\\"\\\\n\\\").split())\\n\\n\\t\\tself._infoMuscles = comm.bcast(self._infoMuscles,root=0)\\n\\t\\tself._infoCommonCellsInMuscles = comm.bcast(self._infoCommonCellsInMuscles,root=0)\\n\\t\\tself._infoSpecialCells = comm.bcast(self._infoSpecialCells,root=0)\\n\\t\\tself._infoCommonMuscleConnections = comm.bcast(self._infoCommonMuscleConnections,root=0)\\n\\t\\tself._infoInterMuscSensorimotorConnections = comm.bcast(self._infoInterMuscSensorimotorConnections,root=0)\\n\\t\\tself._infoSpecialConnections = comm.bcast(self._infoSpecialConnections,root=0)\",\n \"def scan(self):\\n for angle in range(self.MIDPOINT-350, self.MIDPOINT+350, 35):\\n self.servo(angle)\\n self.scan_data[angle] = self.read_distance()\\n #sort the scan data for easier analysis\\n self.scan_data = OrderedDict(sorted(self.scan_data.items()))\",\n \"def fixture_sample_single() -> dict:\\n _sample = {\\n \\\"fastq\\\": \\\"<( zcat read_R1.fastq.gz )\\\",\\n \\\"single_end\\\": True,\\n \\\"sample_id\\\": \\\"single\\\",\\n }\\n return _sample\",\n \"def sample(self):\\n print(\\\"sampling bluetooth arduino\\\")\\n self.sock.send(b'B')\\n data = b''\\n '''while True:\\n data += self.sock.recv(1024)\\n if data.endswith(b'\\\\n'):\\n break\\n '''\\n #self.sock.settimeout(2)\\n try:\\n while True:\\n d = self.sock.recv(255)\\n data += d\\n if d.find(b'\\\\n') != -1:\\n break\\n except Exception as err:\\n print(err)\\n pass\\n print(data)\\n data = json.loads(data.decode())\\n if not any(x == 0 for x in data.values()):\\n for label in self.data_labels:\\n self.data[label].append(data[label])\\n #self.data[\\\"time\\\"].append(time.time() - self.start)\\n print(data)\\n #print(self.data)\\n #return self.data\",\n \"def sample(self, detections):\\n\\n raise NotImplementedError\",\n \"def sample_count(self):\",\n \"def create_samples(self):\\n self._samples = self.load_samples()\\n self.modify_samples()\",\n \"def _get_sample(self):\\n return [layer._get_sample() for layer in self.layers]\",\n \"def process_data(self, spec):\\n with torch.no_grad():\\n \\n assert(len(spec) == 5), 'dataloader should return (spec_masked, pos_enc, mask_label, attn_mask, spec_stacked)'\\n # Unpack and Hack bucket: Bucketing should cause acoustic feature to have shape 1xBxTxD'\\n spec_masked = spec[0].squeeze(0)\\n pos_enc = spec[1].squeeze(0)\\n mask_label = spec[2].squeeze(0)\\n attn_mask = spec[3].squeeze(0)\\n spec_stacked = spec[4].squeeze(0)\\n\\n spec_masked = spec_masked.to(device=self.device)\\n pos_enc = torch.FloatTensor(pos_enc).to(device=self.device)\\n mask_label = torch.ByteTensor(mask_label).to(device=self.device)\\n attn_mask = torch.FloatTensor(attn_mask).to(device=self.device)\\n spec_stacked = spec_stacked.to(device=self.device)\\n\\n return spec_masked, pos_enc, mask_label, attn_mask, spec_stacked # (x, pos_enc, mask_label, attention_mask. y)\",\n \"def create_read_list(samfile):\\n read_sampler = ReadSampler()\\n for line in samfile:\\n line = sam_utils.SamAlignment(line)\\n vals = line.get_aligned_blocks()\\n if len(vals) > 1:\\n logging.info(\\\"Skipping gapped read %s %s\\\"%(line.QNAME, str(vals))) \\n read_sampler.add_read(vals[0])\\n return read_sampler\",\n \"def compileSection(self, j, section, hats):\\n onebar = audio.AudioQuantumList()\\n\\n s1 = self.searchSamples(j, self.tonic)\\n s2 = self.searchSamples(j, (self.tonic + 3) % 12)\\n s3 = self.searchSamples(j, (self.tonic + 9) % 12)\\n\\n biggest = max([s1, s2, s3]) #for music that's barely tonal\\n if not biggest:\\n for i in xrange(0, 12):\\n biggest = self.searchSamples(j, self.tonic + i)\\n if biggest:\\n break\\n\\n if not biggest:\\n raise Exception('Missing samples in section %s of the song!' % j+1)\\n\\n if not s1: s1 = biggest\\n if not s2: s2 = biggest\\n if not s3: s3 = biggest\\n\\n if self.template['target'] == \\\"tatums\\\":\\n f = 4\\n r = 2\\n elif self.template['target'] == \\\"beats\\\":\\n f = 2\\n r = 2\\n elif self.template['target'] == \\\"bars\\\":\\n f = 1\\n r = 1\\n for k in xrange(0, r):\\n for i in xrange(0, 4*f):\\n onebar.append(s1[i % len(s1)])\\n for i in xrange(4*f, 6*f):\\n onebar.append( s2[i % len(s2)] )\\n for i in xrange(6*f, 8*f):\\n onebar.append( s3[i % len(s3)] )\\n if self.original.analysis.time_signature == 4:\\n orig_bar = self.st.shiftTempo(audio.getpieces(self.original, onebar), self.template['tempo']/self.tempo)\\n else:\\n orig_bar = audio.getpieces(self.original, onebar)\\n orig_bar = self.st.shiftTempo(orig_bar, len(orig_bar) / ((44100 * 16 * 2 * 60.0)/self.template['tempo']))\\n if orig_bar.numChannels == 1:\\n orig_bar = self.mono_to_stereo(orig_bar)\\n mixfactor = self.mixfactor(onebar)\\n a = self.truncatemix(\\n audio.mix(\\n audio.AudioData(\\n self.sample_path + self.template['wubs'][self.tonic], \\n sampleRate=44100,\\n numChannels=2,\\n verbose=False\\n ),\\n audio.AudioData(\\n self.sample_path + self.template['splashes'][(j+1) % len(self.template['splashes'])],\\n sampleRate=44100,\\n numChannels=2,\\n verbose=False\\n )\\n ),\\n orig_bar,\\n mixfactor\\n )\\n b = self.truncatemix(\\n audio.mix(\\n audio.AudioData(\\n self.sample_path + self.template['wub_breaks'][self.tonic],\\n sampleRate=44100,\\n numChannels=2,\\n verbose=False\\n ),\\n hats\\n ),\\n orig_bar,\\n mixfactor\\n )\\n return (a, b)\",\n \"def __init__(self, parent):\\n \\n #60 32 bit integers are recorded for the amplifier sample time index \\n self.sample_time_index = []\\n for i in range(60):\\n sample_time = np.int32(struct.unpack('i', parent.rhd.read(4)))[0]\\n self.sample_time_index.append(sample_time)\\n\\n #Amplifier voltages for each channel\\n self.electrode_traces = {}#key: channel name value: voltage trce\\n for amp in parent._AMPLIFIER_CHANNELS:\\n electrode_voltage_trace = []\\n #60 samples per channel, int16\\n for i in range(60):\\n electrode_voltage = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\\n electrode_voltage_trace.append(electrode_voltage)\\n self.electrode_traces[amp] = electrode_voltage_trace \\n\\n #Get voltage from Aux input channels\\n self.auxilary_traces = {}\\n for aux in parent._AUX_CHANNELS:\\n aux_voltage_trace = []\\n #15 samples per channel, int16\\n for i in range(15):\\n aux_voltage = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\\n aux_voltage_trace.append(aux_voltage)\\n self.auxilary_traces[aux] = aux_voltage_trace \\n\\n #get voltage from supply voltage channels\\n self.supply_voltages = {}\\n for sup in parent._SUPPLY_VOLTAGE_CHANNELS:\\n sup_voltage_list = []\\n for i in range(1):\\n sup_voltage = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\\n sup_voltage_list.append(sup_voltage)\\n self.supply_voltages[sup] = sup_voltage_list \\n\\n #get voltage from temerature sensor channels\\n self.temerature_sensor_readings = {}\\n for n in range(parent._TEMP_SENSORS):\\n temp_list = []\\n for i in range(1):\\n temperature = np.int16(struct.unpack('h', parent.rhd.read(2)))[0]\\n temp_list.append(temperature)\\n self.temerature_sensor_readings[n] = temp_list \\n\\n #Get voltage ADC inputs\\n self.board_adc_input_voltages = {}\\n for adc in parent._ADC_INPUT_CHANNELS:\\n adc_input_list = []\\n for i in range(60):\\n adc_input = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\\n adc_input_list.append(adc_input)\\n self.board_adc_input_voltages[adc] = adc_input_list \\n\\n #Get digital input values\\n self.board_digital_inputs = {}\\n for dig in parent._DIGITAL_INPUT_CHANNELS :\\n digital_input_list = []\\n for i in range(60):\\n digital_input = np.uint16(struct.unpack('H', parent.rhd.read(2)))[0]\\n digital_input_list.append(digital_input)\\n self.board_digital_inputs[dig.native_channel_name] = digital_input_list\",\n \"def sample_room(config):\\n room = np.zeros((3,))\\n room[0] = get_sample(config['length'], n_sample=1)[0]\\n room[1] = get_sample(config['width'], n_sample=1)[0]\\n room[2] = get_sample(config['height'], n_sample=1)[0]\\n return room\",\n \"def get_disk_rw(sampling_duration):\\n \\n #get te list of devices\\n with open('/proc/partitions') as f:\\n devices = [re.search('\\\\s([^\\\\s]+)$', line).group(1).strip() for line in re.findall('^\\\\s*[0-9]+\\\\s+[1-9]+.*$', f.read(), flags = re.MULTILINE)]\\n \\n with open('/proc/diskstats') as f1:\\n with open('/proc/diskstats') as f2:\\n content1 = f1.read() #first collection\\n yield {} #yield so that caller can put delay before sampling again\\n content2 = f2.read() #second collection\\n \\n #initialize the dict with interfaces and values\\n data = dict(zip(devices, [dict(zip(['reads', 'writes'], [0, 0])) for device in devices]))\\n\\n for line in content1.splitlines(): #read through first collection\\n for device in [device_x for device_x in devices if '%s ' % device_x in line]:\\n fields = line.strip().split('%s ' % device)[1].split()\\n data[device]['reads'] = int(fields[0])\\n data[device]['writes'] = int(fields[4])\\n break\\n \\n for line in content2.splitlines(): #read through second collection\\n for device in [device_x for device_x in devices if '%s ' % device_x in line]:\\n fields = line.strip().split('%s ' % device)[1].split()\\n data[device]['reads'] = (int(fields[0]) - data[device]['reads']) / float(sampling_duration)\\n data[device]['writes'] = (int(fields[4]) - data[device]['writes']) / float(sampling_duration)\\n break \\n \\n yield data\",\n \"def dataset_prepare_CWRU(self, sample_num, sample_len):\\r\\n\\r\\n logging.info(\\\"generating new dataset with each case has (sample_num = %d, sample_len = %d)\\\"\\r\\n % (sample_num, sample_len))\\r\\n\\r\\n signals, filelabels_wc, filelabels_fs = self.data_clean_CWRU()\\r\\n data, labels_wc, labels_fs = [], [], []\\r\\n for k, signal in enumerate(signals):\\r\\n data.append(ut.signal_split_as_samples(signal, sample_len, sample_num))\\r\\n sample_labels_wc = np.ones((sample_num, 1)) * filelabels_wc[k]\\r\\n sample_labels_wc = ut.onehot_encoding(sample_labels_wc, class_num=10)\\r\\n labels_wc.append(sample_labels_wc)\\r\\n\\r\\n sample_labels_fs = np.ones((sample_num, 1)) * filelabels_fs[k]\\r\\n sample_labels_fs = ut.onehot_encoding(sample_labels_fs, class_num=4)\\r\\n labels_fs.append(sample_labels_fs)\\r\\n\\r\\n for i in range(2):\\r\\n for signal in signals[-4:]:\\r\\n data.append(ut.signal_split_as_samples(signal, sample_len, sample_num))\\r\\n sample_labels_wc = np.zeros((sample_num, 1))\\r\\n sample_labels_wc = ut.onehot_encoding(sample_labels_wc, class_num=10)\\r\\n labels_wc.append(sample_labels_wc)\\r\\n\\r\\n sample_labels_fs = np.zeros((sample_num, 1))\\r\\n sample_labels_fs = ut.onehot_encoding(sample_labels_fs, class_num=4)\\r\\n labels_fs.append(sample_labels_fs)\\r\\n\\r\\n data, labels_wc, labels_fs = np.array(data), np.array(labels_wc), np.array(labels_fs)\\r\\n os.chdir(self.path_cache)\\r\\n np.savez(\\\"CWRU_1D_signal.npz\\\", data=data, labels_wc=labels_wc, labels_fs=labels_fs)\\r\\n os.chdir(self.path)\\r\\n\\r\\n logging.info(\\\"new dataset has been stored\\\")\\r\\n\\r\\n return 0\",\n \"def setup(self):\\n # get unsorted vs sorted units\\n data_dict = mat73.loadmat(self.file)\\n units_unsorted = []\\n units_sorted = []\\n for ch_curr in data_dict['spikes']:\\n units_unsorted.append(ch_curr[0]) # from data description, first unit is unsorted\\n for unit_curr in ch_curr[1:]:\\n if unit_curr is not None:\\n units_sorted.append(unit_curr)\\n \\n # getting binned spikes\\n bin_size_ms = 10\\n # window for binning\\n mintime, maxtime = 100, 0\\n for spk_times_curr in units_sorted:\\n mintime = min(spk_times_curr[0], mintime)\\n maxtime = max(spk_times_curr[-1], maxtime)\\n # get binned spikes\\n spk_bins = np.arange(mintime, maxtime, bin_size_ms/1000)\\n spks_binned = []\\n for i, unit_curr in enumerate(units_sorted):\\n spks_binned_curr, _ = np.histogram(unit_curr, bins=spk_bins, range=(spk_bins[0], spk_bins[-1]))\\n spks_binned.append(spks_binned_curr)\\n self.data = np.array(spks_binned).T\\n\\n self.l = 1 # columns per update\\n l1 = 100 # columns used to initialize\\n self.t = l1\\n self.num_iters = np.floor((self.data.shape[0] - l1 - self.l)/self.l).astype('int')\\n\\n #send to dim reduction\\n init_id = self.client.put([self.data.shape[0], self.data[:l1, :]], \\\"init_data\\\")\\n logger.info(\\\"Putted init data\\\")\\n self.q_out.put(init_id)\",\n \"def samples(self, gp):\\r\\n raise NotImplementedError\",\n \"def create(self):\\n\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"]:\\n continue\\n process_name = sample_info[\\\"process_name_specific\\\"]\\n sample_category = sample_info[\\\"sample_category\\\"]\\n is_mc = (sample_info[\\\"type\\\"] == \\\"mc\\\")\\n\\n logging.info(\\\"Building dictionaries for sample %s...\\\" % process_name)\\n for charge_selection in self.charge_selections:\\n central_or_shift_extensions = [\\\"\\\", \\\"hadd\\\", \\\"addBackgrounds\\\"]\\n central_or_shifts_extended = central_or_shift_extensions + self.central_or_shifts\\n for central_or_shift_or_dummy in central_or_shifts_extended:\\n process_name_extended = [ process_name, \\\"hadd\\\" ]\\n for process_name_or_dummy in process_name_extended:\\n if central_or_shift_or_dummy in [ \\\"hadd\\\" ] and process_name_or_dummy in [ \\\"hadd\\\" ]:\\n continue\\n if central_or_shift_or_dummy != \\\"central\\\" and central_or_shift_or_dummy not in central_or_shift_extensions:\\n if not is_mc:\\n continue\\n if not self.accept_central_or_shift(central_or_shift_or_dummy, sample_info):\\n continue\\n\\n key_dir = getKey(process_name_or_dummy, charge_selection, central_or_shift_or_dummy)\\n for dir_type in [ DKEY_CFGS, DKEY_HIST, DKEY_LOGS, DKEY_RLES ]:\\n initDict(self.dirs, [ key_dir, dir_type ])\\n if dir_type in [ DKEY_CFGS, DKEY_LOGS ]:\\n self.dirs[key_dir][dir_type] = os.path.join(self.get_dir_type(dir_type), dir_type, self.channel,\\n \\\"_\\\".join([ charge_selection ]), process_name_or_dummy, central_or_shift_or_dummy)\\n else:\\n self.dirs[key_dir][dir_type] = os.path.join(self.outputDir, dir_type, self.channel,\\n \\\"_\\\".join([ charge_selection ]), process_name_or_dummy)\\n for subdirectory in [ \\\"comp_jetToTauFakeRate\\\", \\\"makePlots\\\" ]:\\n key_dir = getKey(subdirectory)\\n for dir_type in [ DKEY_CFGS, DKEY_HIST, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT ]:\\n initDict(self.dirs, [ key_dir, dir_type ])\\n if dir_type in [ DKEY_CFGS, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT ]:\\n self.dirs[key_dir][dir_type] = os.path.join(self.get_dir_type(dir_type), dir_type, self.channel, subdirectory)\\n else:\\n self.dirs[key_dir][dir_type] = os.path.join(self.outputDir, dir_type, self.channel, subdirectory)\\n for dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_HIST, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\\n initDict(self.dirs, [ dir_type ])\\n if dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\\n self.dirs[dir_type] = os.path.join(self.get_dir_type(dir_type), dir_type, self.channel)\\n else:\\n self.dirs[dir_type] = os.path.join(self.outputDir, dir_type, self.channel)\\n\\n numDirectories = 0\\n for key in self.dirs.keys():\\n if type(self.dirs[key]) == dict:\\n numDirectories += len(self.dirs[key])\\n else:\\n numDirectories += 1\\n logging.info(\\\"Creating directory structure (numDirectories = %i)\\\" % numDirectories)\\n numDirectories_created = 0;\\n frac = 1\\n for key in self.dirs.keys():\\n if type(self.dirs[key]) == dict:\\n for dir_type in self.dirs[key].keys():\\n create_if_not_exists(self.dirs[key][dir_type])\\n numDirectories_created += len(self.dirs[key])\\n else:\\n create_if_not_exists(self.dirs[key])\\n numDirectories_created = numDirectories_created + 1\\n while 100*numDirectories_created >= frac*numDirectories:\\n logging.info(\\\" %i%% completed\\\" % frac)\\n frac = frac + 1\\n logging.info(\\\"Done.\\\")\\n\\n inputFileLists = {}\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"]:\\n continue\\n logging.info(\\\"Checking input files for sample %s\\\" % sample_info[\\\"process_name_specific\\\"])\\n inputFileLists[sample_name] = generateInputFileList(sample_info, self.max_files_per_job)\\n\\n self.inputFileIds = {}\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"]:\\n continue\\n\\n process_name = sample_info[\\\"process_name_specific\\\"]\\n inputFileList = inputFileLists[sample_name]\\n\\n logging.info(\\\"Creating configuration files to run '%s' for sample %s\\\" % (self.executable_analyze, process_name))\\n\\n is_mc = (sample_info[\\\"type\\\"] == \\\"mc\\\")\\n sample_category = sample_info[\\\"sample_category\\\"]\\n\\n for charge_selection in self.charge_selections:\\n for central_or_shift in self.central_or_shifts:\\n \\n if central_or_shift != \\\"central\\\" and not is_mc:\\n continue\\n if not self.accept_central_or_shift(central_or_shift, sample_info):\\n continue\\n\\n # build config files for executing analysis code\\n key_analyze_dir = getKey(process_name, charge_selection, central_or_shift)\\n\\n for jobId in inputFileList.keys():\\n\\n analyze_job_tuple = (process_name, charge_selection, central_or_shift, jobId)\\n key_analyze_job = getKey(*analyze_job_tuple)\\n ntupleFiles = inputFileList[jobId]\\n if len(ntupleFiles) == 0:\\n logging.warning(\\\"No input ntuples for %s --> skipping job !!\\\" % (key_analyze_job))\\n continue\\n\\n cfgFile_modified_path = os.path.join(self.dirs[key_analyze_dir][DKEY_CFGS], \\\"analyze_%s_%s_%s_%i_cfg.py\\\" % analyze_job_tuple)\\n logFile_path = os.path.join(self.dirs[key_analyze_dir][DKEY_LOGS], \\\"analyze_%s_%s_%s_%i.log\\\" % analyze_job_tuple)\\n histogramFile_path = os.path.join(self.dirs[key_analyze_dir][DKEY_HIST], \\\"analyze_%s_%s_%s_%i.root\\\" % analyze_job_tuple)\\n rleOutputFile_path = os.path.join(self.dirs[key_analyze_dir][DKEY_RLES], \\\"rle_%s_%s_%s_%i.txt\\\" % analyze_job_tuple) \\\\\\n if self.select_rle_output else \\\"\\\"\\n\\n self.jobOptions_analyze[key_analyze_job] = {\\n 'ntupleFiles' : ntupleFiles,\\n 'cfgFile_modified' : cfgFile_modified_path,\\n 'histogramFile' : histogramFile_path,\\n 'logFile' : logFile_path,\\n 'chargeSelection' : charge_selection,\\n 'jet_minPt' : self.jet_minPt,\\n 'jet_maxPt' : self.jet_maxPt,\\n 'jet_minAbsEta' : self.jet_minAbsEta,\\n 'jet_maxAbsEta' : self.jet_maxAbsEta,\\n 'hadTau_selection_tight' : self.hadTau_selection_tight,\\n 'hadTauSelection_denominator' : self.hadTau_selection_denominator,\\n 'hadTauSelections_numerator' : self.hadTau_selections_numerator,\\n 'trigMatchingOptions' : self.trigMatchingOptions,\\n 'selEventsFileName_output' : rleOutputFile_path,\\n 'absEtaBins' : self.absEtaBins,\\n 'decayModes' : self.decayModes,\\n 'central_or_shift' : central_or_shift,\\n 'central_or_shifts_local' : [],\\n 'apply_hlt_filter' : self.hlt_filter,\\n }\\n self.createCfg_analyze(self.jobOptions_analyze[key_analyze_job], sample_info)\\n\\n # initialize input and output file names for hadd_stage1\\n key_hadd_stage1_dir = getKey(process_name, charge_selection)\\n hadd_stage1_job_tuple = (process_name, charge_selection)\\n key_hadd_stage1_job = getKey(*hadd_stage1_job_tuple)\\n if not key_hadd_stage1_job in self.inputFiles_hadd_stage1:\\n self.inputFiles_hadd_stage1[key_hadd_stage1_job] = []\\n self.inputFiles_hadd_stage1[key_hadd_stage1_job].append(self.jobOptions_analyze[key_analyze_job]['histogramFile'])\\n self.outputFile_hadd_stage1[key_hadd_stage1_job] = os.path.join(self.dirs[key_hadd_stage1_dir][DKEY_HIST],\\n \\\"hadd_stage1_%s_%s.root\\\" % hadd_stage1_job_tuple)\\n\\n # initialize input and output file names for hadd_stage2\\n key_hadd_stage1_job = getKey(process_name, charge_selection)\\n key_hadd_stage2_dir = getKey(\\\"hadd\\\", charge_selection)\\n key_hadd_stage2_job = getKey(charge_selection)\\n if not key_hadd_stage2_job in self.inputFiles_hadd_stage2:\\n self.inputFiles_hadd_stage2[key_hadd_stage2_job] = []\\n self.inputFiles_hadd_stage2[key_hadd_stage2_job].append(self.outputFile_hadd_stage1[key_hadd_stage1_job])\\n self.outputFile_hadd_stage2[key_hadd_stage2_job] = os.path.join(self.dirs[key_hadd_stage2_dir][DKEY_HIST],\\n \\\"hadd_stage2_%s.root\\\" % charge_selection)\\n\\n logging.info(\\\"Creating configuration files for executing 'comp_jetToTauFakeRate'\\\")\\n for charge_selection in self.charge_selections:\\n charge_key = \\\"comp_%s\\\" % charge_selection\\n self.comp_input_files[charge_key] = []\\n for trigMatchingOption in self.trigMatchingOptions:\\n key_hadd_stage2_job = getKey(charge_selection)\\n key_comp_jetToTauFakeRate_dir = getKey(\\\"comp_jetToTauFakeRate\\\")\\n key_comp_jetToTauFakeRate_job = getKey(charge_selection, trigMatchingOption)\\n self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job] = {\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2_job],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[DKEY_CFGS], \\\"comp_jetToTauFakeRate_%s_%s_cfg.py\\\" % (charge_selection, trigMatchingOption)),\\n 'outputFile' : os.path.join(\\n self.dirs[DKEY_HIST], \\\"comp_jetToTauFakeRate_%s_%s.root\\\" % (charge_selection, trigMatchingOption)),\\n 'logFile' : os.path.join(\\n self.dirs[DKEY_LOGS], \\\"comp_jetToTauFakeRate_%s_%s.log\\\" % (charge_selection, trigMatchingOption)),\\n 'looseRegion' : \\\"jetToTauFakeRate_%s_%s/denominator/\\\" % (charge_selection, trigMatchingOption),\\n 'tightRegion' : \\\"jetToTauFakeRate_%s_%s/numerator/\\\" % (charge_selection, trigMatchingOption),\\n 'absEtaBins' : self.absEtaBins,\\n 'ptBins' : self.ptBins,\\n 'decayModes' : self.decayModes,\\n 'hadTauSelections' : self.hadTau_selections_numerator,\\n 'trigMatchingOption' : trigMatchingOption,\\n 'plots_outputFileName' : os.path.join(self.dirs[key_comp_jetToTauFakeRate_dir][DKEY_PLOT], \\\"comp_jetToTauFakeRate_%s.png\\\" % trigMatchingOption)\\n }\\n self.createCfg_comp_jetToTauFakeRate(self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job])\\n comp_output = self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job]['outputFile']\\n self.targets.append(comp_output)\\n self.comp_input_files[charge_key].append(comp_output)\\n self.comp_output_files[charge_key] = os.path.join(self.dirs[DKEY_HIST], \\\"comp_jetToTauFakeRate_%s.root\\\" % charge_selection)\\n\\n logging.info(\\\"Creating configuration files to run 'makePlots'\\\")\\n for charge_selection in self.charge_selections:\\n key_hadd_stage2_job = getKey(charge_selection)\\n key_makePlots_dir = getKey(\\\"makePlots\\\")\\n key_makePlots_job = getKey(charge_selection) \\n self.jobOptions_make_plots[key_makePlots_job] = {\\n 'executable' : self.executable_make_plots,\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2_job],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[key_makePlots_dir][DKEY_CFGS], \\\"makePlots_%s_cfg.py\\\" % self.channel),\\n 'outputFile' : os.path.join(\\n self.dirs[key_makePlots_dir][DKEY_PLOT], \\\"makePlots_%s.png\\\" % self.channel),\\n 'histogramDir' : \\\"jetToTauFakeRate_%s\\\" % charge_selection,\\n 'label' : None,\\n 'make_plots_backgrounds' : self.make_plots_backgrounds\\n }\\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\\n for trigMatchingOption in self.trigMatchingOptions:\\n self.cfgFile_make_plots = self.cfgFile_make_plots_denominator\\n for absEtaBin in [ \\\"absEtaLt1_5\\\", \\\"absEta1_5to9_9\\\" ]:\\n key_hadd_stage2_job = getKey(charge_selection)\\n key_makePlots_job = getKey(charge_selection, trigMatchingOption, absEtaBin, \\\"denominator\\\") \\n self.jobOptions_make_plots[key_makePlots_job] = {\\n 'executable' : self.executable_make_plots,\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2_job],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[key_makePlots_dir][DKEY_CFGS], \\\"makePlots_%s_%s_%s_denominator_%s_cfg.py\\\" % \\\\\\n (self.channel, charge_selection, trigMatchingOption, absEtaBin)),\\n 'outputFile' : os.path.join(\\n self.dirs[key_makePlots_dir][DKEY_PLOT], \\\"makePlots_%s_%s_%s_denominator_%s.png\\\" % (self.channel, charge_selection, trigMatchingOption, absEtaBin)),\\n 'histogramDir' : \\\"jetToTauFakeRate_%s_%s/denominator/%s\\\" % (charge_selection, trigMatchingOption, absEtaBin),\\n 'label' : None,\\n 'make_plots_backgrounds' : self.make_plots_backgrounds\\n }\\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\\n for hadTau_selection_numerator in self.hadTau_selections_numerator:\\n key_hadd_stage2_job = getKey(charge_selection)\\n key_makePlots_job = getKey(charge_selection, trigMatchingOption, absEtaBin, \\\"numerator\\\", hadTau_selection_numerator)\\n self.jobOptions_make_plots[key_makePlots_job] = {\\n 'executable' : self.executable_make_plots,\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2_job],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[key_makePlots_dir][DKEY_CFGS], \\\"makePlots_%s_%s_%s_numerator_%s_%s_cfg.py\\\" % \\\\\\n (self.channel, charge_selection, trigMatchingOption, hadTau_selection_numerator, absEtaBin)),\\n 'outputFile' : os.path.join(\\n self.dirs[key_makePlots_dir][DKEY_PLOT], \\\"makePlots_%s_%s_%s_numerator_%s_%s.png\\\" % \\\\\\n (self.channel, charge_selection, trigMatchingOption, hadTau_selection_numerator, absEtaBin)),\\n 'histogramDir' : \\\"jetToTauFakeRate_%s_%s/numerator/%s/%s\\\" % (charge_selection, trigMatchingOption, hadTau_selection_numerator, absEtaBin),\\n 'label' : None,\\n 'make_plots_backgrounds' : self.make_plots_backgrounds\\n }\\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\\n\\n self.sbatchFile_analyze = os.path.join(self.dirs[DKEY_SCRIPTS], \\\"sbatch_analyze_%s.py\\\" % self.channel)\\n self.sbatchFile_comp_jetToTauFakeRate = os.path.join(self.dirs[DKEY_SCRIPTS], \\\"sbatch_comp_jetToTauFakeRate.py\\\")\\n if self.is_sbatch:\\n logging.info(\\\"Creating script for submitting '%s' jobs to batch system\\\" % self.executable_analyze)\\n self.createScript_sbatch_analyze(self.executable_analyze, self.sbatchFile_analyze, self.jobOptions_analyze)\\n logging.info(\\\"Creating script for submitting '%s' jobs to batch system\\\" % self.executable_comp_jetToTauFakeRate)\\n self.createScript_sbatch(self.executable_comp_jetToTauFakeRate, self.sbatchFile_comp_jetToTauFakeRate, self.jobOptions_comp_jetToTauFakeRate)\\n\\n lines_makefile = []\\n self.addToMakefile_analyze(lines_makefile)\\n self.addToMakefile_hadd_stage1(lines_makefile)\\n self.addToMakefile_hadd_stage2(lines_makefile, make_dependency = \\\"phony_hadd_stage1\\\", max_mem = '4096M')\\n self.addToMakefile_comp_jetToTauFakeRate(lines_makefile)\\n self.addToMakefile_comp_hadd(lines_makefile)\\n self.addToMakefile_make_plots(lines_makefile)\\n self.createMakefile(lines_makefile)\\n\\n logging.info(\\\"Done.\\\")\\n\\n return self.num_jobs\",\n \"def scan(self):\\n for angle in range(self.MIDPOINT-400, self.MIDPOINT+401, 100):\\n self.servo(angle)\\n self.scan_data[angle] = self.read_distance()\\n #sort the scan data for easier analysis\\n self.scan_data = OrderedDict(sorted(self.scan_data.items()))\",\n \"def rebuild(self):\\n self.from_samples(self.samples)\",\n \"def _sample_single(self):\\n ss = super(SuperResolutions, self)._sample_single()\\n image = ss['data']\\n # Down sample\\n max_down_sample = max(self.data_down_sample, self.label_down_sample)\\n if self.is_down_sample:\\n images = []\\n images.append(image)\\n for i in range(max_down_sample):\\n image = self.downsample(image)\\n images.append(image)\\n data = images[self.data_down_sample]\\n label = images[self.label_down_sample]\\n return {'data': data, 'label': label}\",\n \"def test_irr_random_chread(irregular_written_data):\\n\\n fetches = 20\\n channels = [1,3]\\n starts = np.random.randint(0, 5e4, fetches)\\n stops = starts + np.random.randint(0, 1e6)\\n\\n fp, written = irregular_written_data\\n with openEDF(fp) as reader:\\n reader.channels = channels\\n for start, stop in zip(starts, stops):\\n arr = reader.read(start, stop, padvalue=np.NaN)\\n x = written[channels, start:stop]\\n #imprecision due to 2-byte conversion so tolerance set to 1 unit\\n assert np.allclose(arr, x, equal_nan=True, atol=1)\",\n \"def read_data(filename):\\n from intanutil.read_header import read_header\\n from intanutil.get_bytes_per_data_block import get_bytes_per_data_block\\n from intanutil.read_one_data_block import read_one_data_block\\n from intanutil.notch_filter import notch_filter\\n from intanutil.data_to_result import data_to_result \\n \\n\\n tic = time.time()\\n fid = open(filename, 'rb')\\n filesize = os.path.getsize(filename)\\n\\n header = read_header(fid)\\n\\n print('Found {} amplifier channel{}.'.format(header['num_amplifier_channels'], plural(header['num_amplifier_channels'])))\\n print('Found {} auxiliary input channel{}.'.format(header['num_aux_input_channels'], plural(header['num_aux_input_channels'])))\\n print('Found {} supply voltage channel{}.'.format(header['num_supply_voltage_channels'], plural(header['num_supply_voltage_channels'])))\\n print('Found {} board ADC channel{}.'.format(header['num_board_adc_channels'], plural(header['num_board_adc_channels'])))\\n print('Found {} board digital input channel{}.'.format(header['num_board_dig_in_channels'], plural(header['num_board_dig_in_channels'])))\\n print('Found {} board digital output channel{}.'.format(header['num_board_dig_out_channels'], plural(header['num_board_dig_out_channels'])))\\n print('Found {} temperature sensors channel{}.'.format(header['num_temp_sensor_channels'], plural(header['num_temp_sensor_channels'])))\\n print('')\\n\\n # Determine how many samples the data file contains.\\n bytes_per_block = get_bytes_per_data_block(header)\\n\\n # How many data blocks remain in this file?\\n data_present = False\\n bytes_remaining = filesize - fid.tell()\\n if bytes_remaining > 0:\\n data_present = True\\n\\n if bytes_remaining % bytes_per_block != 0:\\n raise Exception('Something is wrong with file size : should have a whole number of data blocks')\\n\\n num_data_blocks = int(bytes_remaining / bytes_per_block)\\n\\n num_amplifier_samples = header['num_samples_per_data_block'] * num_data_blocks\\n num_aux_input_samples = int((header['num_samples_per_data_block'] / 4) * num_data_blocks)\\n num_supply_voltage_samples = 1 * num_data_blocks\\n num_board_adc_samples = header['num_samples_per_data_block'] * num_data_blocks\\n num_board_dig_in_samples = header['num_samples_per_data_block'] * num_data_blocks\\n num_board_dig_out_samples = header['num_samples_per_data_block'] * num_data_blocks\\n\\n record_time = num_amplifier_samples / header['sample_rate']\\n\\n if data_present:\\n print('File contains {:0.3f} seconds of data. Amplifiers were sampled at {:0.2f} kS/s.'.format(record_time, header['sample_rate'] / 1000))\\n else:\\n print('Header file contains no data. Amplifiers were sampled at {:0.2f} kS/s.'.format(header['sample_rate'] / 1000))\\n\\n if data_present:\\n # Pre-allocate memory for data.\\n print('')\\n print('Allocating memory for data...')\\n\\n data = {}\\n if (header['version']['major'] == 1 and header['version']['minor'] >= 2) or (header['version']['major'] > 1):\\n data['t_amplifier'] = np.zeros(num_amplifier_samples, dtype=np.int_)\\n else:\\n data['t_amplifier'] = np.zeros(num_amplifier_samples, dtype=np.uint)\\n\\n data['amplifier_data'] = np.zeros([header['num_amplifier_channels'], num_amplifier_samples], dtype=np.uint)\\n data['aux_input_data'] = np.zeros([header['num_aux_input_channels'], num_aux_input_samples], dtype=np.uint)\\n data['supply_voltage_data'] = np.zeros([header['num_supply_voltage_channels'], num_supply_voltage_samples], dtype=np.uint)\\n data['temp_sensor_data'] = np.zeros([header['num_temp_sensor_channels'], num_supply_voltage_samples], dtype=np.uint)\\n data['board_adc_data'] = np.zeros([header['num_board_adc_channels'], num_board_adc_samples], dtype=np.uint)\\n \\n # by default, this script interprets digital events (digital inputs and outputs) as booleans\\n # if unsigned int values are preferred(0 for False, 1 for True), replace the 'dtype=np.bool_' argument with 'dtype=np.uint' as shown\\n # the commented line below illustrates this for digital input data; the same can be done for digital out\\n \\n #data['board_dig_in_data'] = np.zeros([header['num_board_dig_in_channels'], num_board_dig_in_samples], dtype=np.uint)\\n data['board_dig_in_data'] = np.zeros([header['num_board_dig_in_channels'], num_board_dig_in_samples], dtype=np.bool_)\\n data['board_dig_in_raw'] = np.zeros(num_board_dig_in_samples, dtype=np.uint)\\n \\n data['board_dig_out_data'] = np.zeros([header['num_board_dig_out_channels'], num_board_dig_out_samples], dtype=np.bool_)\\n data['board_dig_out_raw'] = np.zeros(num_board_dig_out_samples, dtype=np.uint)\\n\\n # Read sampled data from file.\\n print('Reading data from file...')\\n\\n # Initialize indices used in looping\\n indices = {}\\n indices['amplifier'] = 0\\n indices['aux_input'] = 0\\n indices['supply_voltage'] = 0\\n indices['board_adc'] = 0\\n indices['board_dig_in'] = 0\\n indices['board_dig_out'] = 0\\n\\n print_increment = 10\\n percent_done = print_increment\\n for i in range(num_data_blocks):\\n read_one_data_block(data, header, indices, fid)\\n\\n # Increment indices\\n indices['amplifier'] += header['num_samples_per_data_block']\\n indices['aux_input'] += int(header['num_samples_per_data_block'] / 4)\\n indices['supply_voltage'] += 1\\n indices['board_adc'] += header['num_samples_per_data_block']\\n indices['board_dig_in'] += header['num_samples_per_data_block']\\n indices['board_dig_out'] += header['num_samples_per_data_block'] \\n\\n fraction_done = 100 * (1.0 * i / num_data_blocks)\\n if fraction_done >= percent_done:\\n print('{}% done...'.format(percent_done))\\n percent_done = percent_done + print_increment\\n\\n # Make sure we have read exactly the right amount of data.\\n bytes_remaining = filesize - fid.tell()\\n if bytes_remaining != 0: raise Exception('Error: End of file not reached.')\\n\\n\\n\\n # Close data file.\\n fid.close()\\n\\n if (data_present):\\n print('Parsing data...')\\n\\n # Extract digital input channels to separate variables.\\n for i in range(header['num_board_dig_in_channels']):\\n data['board_dig_in_data'][i, :] = np.not_equal(np.bitwise_and(data['board_dig_in_raw'], (1 << header['board_dig_in_channels'][i]['native_order'])), 0)\\n\\n # Extract digital output channels to separate variables.\\n for i in range(header['num_board_dig_out_channels']):\\n data['board_dig_out_data'][i, :] = np.not_equal(np.bitwise_and(data['board_dig_out_raw'], (1 << header['board_dig_out_channels'][i]['native_order'])), 0)\\n\\n # Scale voltage levels appropriately.\\n data['amplifier_data'] = np.multiply(0.195, (data['amplifier_data'].astype(np.int32) - 32768)) # units = microvolts\\n data['aux_input_data'] = np.multiply(37.4e-6, data['aux_input_data']) # units = volts\\n data['supply_voltage_data'] = np.multiply(74.8e-6, data['supply_voltage_data']) # units = volts\\n if header['eval_board_mode'] == 1:\\n data['board_adc_data'] = np.multiply(152.59e-6, (data['board_adc_data'].astype(np.int32) - 32768)) # units = volts\\n elif header['eval_board_mode'] == 13:\\n data['board_adc_data'] = np.multiply(312.5e-6, (data['board_adc_data'].astype(np.int32) - 32768)) # units = volts\\n else:\\n data['board_adc_data'] = np.multiply(50.354e-6, data['board_adc_data']) # units = volts\\n data['temp_sensor_data'] = np.multiply(0.01, data['temp_sensor_data']) # units = deg C\\n\\n # Check for gaps in timestamps.\\n num_gaps = np.sum(np.not_equal(data['t_amplifier'][1:]-data['t_amplifier'][:-1], 1))\\n if num_gaps == 0:\\n print('No missing timestamps in data.')\\n else:\\n print('Warning: {0} gaps in timestamp data found. Time scale will not be uniform!'.format(num_gaps))\\n\\n # Scale time steps (units = seconds).\\n data['t_amplifier'] = data['t_amplifier'] / header['sample_rate']\\n data['t_aux_input'] = data['t_amplifier'][range(0, len(data['t_amplifier']), 4)]\\n data['t_supply_voltage'] = data['t_amplifier'][range(0, len(data['t_amplifier']), header['num_samples_per_data_block'])]\\n data['t_board_adc'] = data['t_amplifier']\\n data['t_dig'] = data['t_amplifier']\\n data['t_temp_sensor'] = data['t_supply_voltage']\\n\\n # If the software notch filter was selected during the recording, apply the\\n # same notch filter to amplifier data here.\\n if header['notch_filter_frequency'] > 0 and header['version']['major'] < 3:\\n print('Applying notch filter...')\\n\\n print_increment = 10\\n percent_done = print_increment\\n for i in range(header['num_amplifier_channels']):\\n data['amplifier_data'][i,:] = notch_filter(data['amplifier_data'][i,:], header['sample_rate'], header['notch_filter_frequency'], 10)\\n\\n fraction_done = 100 * (i / header['num_amplifier_channels'])\\n if fraction_done >= percent_done:\\n print('{}% done...'.format(percent_done))\\n percent_done += print_increment\\n else:\\n data = [];\\n\\n # Move variables to result struct.\\n result = data_to_result(header, data, data_present)\\n\\n print('Done! Elapsed time: {0:0.1f} seconds'.format(time.time() - tic))\\n return result\",\n \"def generate_sample(sample_size, multiplicity, sample_name, height, width, treble_tp_key, bass_tp_key, treble_cp_key, bass_cp_key, rest_prob, measure_length_choices=(8, 12, 16), key_number_choices=tuple(range(-7, 8))):\\n \\n t = time.time()\\n if not os.path.exists(sample_name + '/'):\\n os.mkdir(sample_name + '/')\\n \\n # the neural net needs images of measures, pseudocode for those images, and the key and time signatures of those measures\\n pc_data = []\\n images = []\\n measure_lengths = []\\n key_numbers = []\\n \\n for i in range(sample_size):\\n print(f'{i}/{sample_size} time: {time.time() - t} seconds')\\n \\n # pick random key and time signatures\\n measure_length = np.random.choice(measure_length_choices)\\n key_number = np.random.choice(key_number_choices)\\n \\n # generate the xml for a measure\\n soup = generate_measure(measure_length, key_number, rest_prob, treble_tp_key, bass_tp_key, treble_cp_key, bass_cp_key)\\n \\n # write the xml to a file\\n with open('temp.musicxml', 'w+') as f:\\n f.write(str(soup))\\n \\n # call musescore to convert the xml to a png and and svg\\n subprocess.call(['mscore', '-S', str(pathlib.Path.home()) + '/Documents/MuseScore2/Styles/custom_style.mss', 'temp.musicxml', '-o', 'temp.mscx'])\\n subprocess.call(['mscore', 'temp.mscx', '-o', 'temp.png'])\\n subprocess.call(['mscore', 'temp.mscx', '-o', 'temp.svg'])\\n png_path = 'temp-1.png'\\n svg_path = 'temp-1.svg'\\n \\n # create multiple copies of the measure, with the image distorted in different ways\\n for _ in range(multiplicity):\\n # use the png and svg to appropriately crop the image\\n image = crop(png_path, svg_path)\\n \\n # distort the image\\n image = random_augmentation(image, height, width)\\n \\n # make sure the image is encoded as an integer, to save space\\n image = (image*255).astype(np.uint8)\\n \\n # add the image data to the lists\\n images.append(image)\\n measure_lengths.append(measure_length)\\n key_numbers.append(key_number)\\n\\n # record the pseucode, instead of the xml\\n # this line has to go down here since xml_to_pc changes soup in place\\n pc = ['<START>'] + xml_to_pc(soup) + ['<END>']\\n for _ in range(multiplicity):\\n pc_data.append(pc)\\n \\n # remove the files used in constructing the sample item\\n os.remove('temp.musicxml')\\n os.remove('temp.mscx')\\n os.remove('temp-1.png')\\n os.remove('temp-1.svg')\\n \\n # after generating the sample, save it to a folder\\n with open(sample_name + '/' + 'pc_data.json', 'w+') as f:\\n json.dump(pc_data, f)\\n measure_lengths = np.array(measure_lengths)\\n key_numbers = np.array(key_numbers)\\n images = np.array(images)\\n np.save(sample_name + '/' + 'measure_lengths.npy', measure_lengths)\\n np.save(sample_name + '/' + 'key_numbers.npy', key_numbers)\\n np.save(sample_name + '/' + 'images.npy', images)\\n \\n time_elapsed = time.time() - t\\n \\n # save info about the sample to a text file\\n info = {'sample_name': sample_name,\\n 'sample_size': sample_size,\\n 'multiplicity': multiplicity,\\n 'treble_tp_key': treble_tp_key,\\n 'bass_tp_key': bass_tp_key,\\n 'treble_cp_key': treble_cp_key,\\n 'bass_cp_key': bass_cp_key,\\n 'rest_prob': rest_prob,\\n 'measure_length_choices': list(measure_length_choices),\\n 'key_number_choices': list(key_number_choices),\\n 'time_elapsed': time_elapsed}\\n with open(sample_name + '/' + 'info.json', 'w+') as f:\\n json.dump(info, f)\",\n \"def sample(self):\\n raise NotImplementedError(\\\"Override me!\\\")\",\n \"def fill_buffer(self):\\n num_of_smp = 0\\n while num_of_smp < self.buf_size:\\n c, t = self.inlet.pull_chunk(timeout=0.0)\\n new_c = []\\n new_t = []\\n while c:\\n new_c += c\\n new_t += t\\n c, t = self.inlet.pull_chunk(timeout=0.0)\\n\\n # add samples to buffer\\n if any(new_c):\\n # add samples\\n num_of_smp += len(new_c)\\n data_v = [item for sublist in new_c for item in sublist]\\n self.gbuffer = np.roll(self.gbuffer, -len(data_v))\\n self.gbuffer[-len(data_v):] = data_v\\n # add timestamps\\n if new_t:\\n self.gtimes = np.roll(self.gtimes, -len(new_t))\\n self.gtimes[-len(new_t):] = new_t\",\n \"def __init__(self, n_per_sample, title, unit):\\n self.min_sample = 0xffffffffffffffff\\n self.max_sample = 0\\n self.n_per_sample = n_per_sample\\n self.title = title\\n self.unit = unit\\n self.sum_ = 0\\n self.count = 0\\n self.sample_lock = threading.Lock()\",\n \"def samples():\\n f = open(config['samples'], \\\"r\\\")\\n samp=[]\\n for line in f:\\n samp.append(line.strip().split()[0])\\n return samp\",\n \"def _set_sample(self, sample, PB_X, t):\\n for sensor in PB_X.keys():\\n sample.set(sensor, np.array(PB_X[sensor]), t=t+1)\",\n \"def _handler_sample(self, *args, **kwargs):\\n next_state = None\\n timeout = time.time() + SAMPLE_TIMEOUT\\n\\n for i in self._units:\\n self._do_command(Command.READ, i)\\n\\n particles = self.wait_for_particles([DataParticleType.D1000_PARSED], timeout)\\n\\n return next_state, (next_state, particles)\",\n \"def merge_evio_skims(run, seqno, slices):\\n inset = {\\\"BCAL-LED\\\": \\\"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.BCAL-LED.evio\\\",\\n \\\"DIRC-LED\\\": \\\"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.DIRC-LED.evio\\\",\\n \\\"FCAL-LED\\\": \\\"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.FCAL-LED.evio\\\",\\n \\\"CCAL-LED\\\": \\\"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.CCAL-LED.evio\\\",\\n \\\"random\\\": \\\"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.random.evio\\\",\\n \\\"omega\\\": \\\"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.omega.evio\\\",\\n \\\"sync\\\": \\\"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.sync.evio\\\",\\n \\\"ps\\\": \\\"hd_rawdata_{0:06d}_{1:03d}+{2},{3}.ps.evio\\\",\\n }\\n outset = {\\\"BCAL-LED\\\": \\\"BCAL-LED_{0:06d}_{1:03d}.evio\\\",\\n \\\"DIRC-LED\\\": \\\"DIRC-LED_{0:06d}_{1:03d}.evio\\\",\\n \\\"FCAL-LED\\\": \\\"FCAL-LED_{0:06d}_{1:03d}.evio\\\",\\n \\\"CCAL-LED\\\": \\\"CCAL-LED_{0:06d}_{1:03d}.evio\\\",\\n \\\"random\\\": \\\"random_{0:06d}_{1:03d}.evio\\\",\\n \\\"omega\\\": \\\"omega_{0:06d}_{1:03d}.evio\\\",\\n \\\"sync\\\": \\\"sync_{0:06d}_{1:03d}.evio\\\",\\n \\\"ps\\\": \\\"ps_{0:06d}_{1:03d}.evio\\\",\\n }\\n badslices = []\\n slicepatt = re.compile(r\\\"([1-9][0-9]*),([1-9][0-9]*)/\\\")\\n for iset in inset:\\n ofile = outset[iset].format(run, seqno)\\n ifiles = []\\n for sl in slices:\\n ifile = \\\"{0},{1}/\\\".format(sl[0], sl[1]) +\\\\\\n inset[iset].format(run, seqno, sl[0], sl[1])\\n if iset == \\\"sync\\\" and not os.path.exists(ifile):\\n print(\\\"Warning in merge_evio_skims - \\\",\\n \\\"missing sync event skim \\\",\\n \\\"in slice {0},{1}\\\".format(sl[0], sl[1])\\n )\\n continue\\n elif iset == \\\"omega\\\" and not os.path.exists(ifile):\\n print(\\\"Warning in merge_evio_skims - \\\",\\n \\\"missing omega event skim \\\",\\n \\\"in slice {0},{1}\\\".format(sl[0], sl[1])\\n )\\n continue\\n ifiles.append(ifile)\\n cmd = subprocess.Popen([\\\"eviocat\\\", \\\"-o\\\", ofile] + ifiles,\\n stderr=subprocess.PIPE)\\n elog = cmd.communicate()\\n if cmd.returncode != 0:\\n for eline in elog[1].decode(\\\"ascii\\\").split('\\\\n'):\\n badslice = slicepatt.search(eline)\\n if badslice:\\n badslices.append(\\\"{0},{1}\\\".format(badslice.group(1),\\n badslice.group(2)))\\n sys.stderr.write(eline + '\\\\n')\\n sys.stderr.write(\\\"Error on output file {0}\\\".format(ofile) +\\n \\\" - evio file merging failed!\\\\n\\\")\\n sys.stderr.flush()\\n continue\\n odir = output_area + \\\"/\\\" + iset + \\\"/{0:06d}\\\".format(run)\\n upload(ofile, odir)\\n return badslices\",\n \"def run(self):\\n\\t\\trun_start_timestamp = time.clock()\\n\\t\\texperiment_start_time = time.strftime(\\\"%H_%M_%S_%m_%d_%Y\\\", time.localtime())\\n\\t\\tprint \\\"starting dataset at {}\\\\n\\\".format(experiment_start_time)\\n\\t\\tdata_file = \\\"raw_data/data_\\\" + experiment_start_time + \\\".csv\\\"\\n\\t\\twith open(data_file, 'a') as f:\\n\\t\\t\\tf.write(\\\"Packet, Sample offset, Latency (ms), Sample\\\\n\\\")\\n\\n\\t\\t##### EXPERIMENT SETUP #####\\n\\t\\t# sample for a max of 1.5 seconds\\n\\t\\t# approximate number of samples assuming ~500ms latency per packet\\n\\t\\tnSamples = (int) (1.5 * self.sampling_freq)\\n\\n\\t\\t#csamples, lost, corrupted\\n\\t\\tbuffer_info = [0, 0, 0]\\n\\n\\t\\tnum_packets_received = 0\\n\\t\\tnum_packets_missed = 0\\n\\t\\tnum_acks_missed = 0\\n\\n\\t\\t# array to hold indices of packets missed\\n\\t\\tpacket_number_missed = []\\n\\n\\t\\t# num_packets_received + num_packets_missed must equal num_tries\\n\\t\\tnum_tries = 0\\n\\n\\t\\t# ready for next button press if previous packet has been handled\\n\\t\\t# and if instruments, variables are configured for next packet\\n\\t\\tlast_packet_handled = True\\n\\t\\t# keep track of if current packet has been received\\n\\t\\tpacket_received = True\\n\\n\\t\\t#keep track of previous packet acknowledgment\\n\\t\\tack_missed = False\\n\\n\\t\\t##### END SETUP #####\\n\\n\\t\\t##### MAIN LOOP of experiment. #####\\n\\t\\t# runs for the duration of the experiment\\n\\t\\t#note: openmote toggles its pins every packet creation and reception\\n\\n\\t\\twhile num_tries < self.num_packets_experiment:\\n\\t\\t\\t# initialize \\\"trash\\\" array to clear all buffer samples before starting button press\\n\\t\\t\\t# this must be able to hold 4096 samples, 2 bytes each\\n\\t\\t\\ttrashSamples = (c_uint16 * 4096)()\\n\\n\\t\\t\\t#clear buffer\\n\\t\\t\\tbuffer_info = self._copy_buffer_samples(buffer_info, nSamples, trashSamples, copy_all_samples=True)\\n\\n\\t\\t\\t# clear rgwSamples for next packet\\n\\t\\t\\trgwSamples = (c_uint16 * nSamples)()\\n\\n\\t\\t\\t# reset and configure DigitalIO\\n\\t\\t\\tsteady_state_DIO = self._configure_DigitalIO()\\n\\n\\t\\t\\t# reset and configure DigitalIn to take nSamples on trigger\\n\\t\\t\\t# set DigitalIn trigger when button_press_mirror_bit channel is raised (this should start sampling)\\n\\t\\t\\tself._configure_DigitalIn(nSamples, self.button_press_mirror_bit)\\n\\n\\t\\t\\tready_for_next_button_press = True\\n\\t\\t\\tbroke_early = False\\n\\n\\t\\t\\t#print \\\"begin acquisition {}\\\".format(num_tries + 1)\\n\\t\\t\\tprev_csamples, curr_csamples = 0, 0\\n\\n\\t\\t\\tif ack_missed:\\n\\t\\t\\t\\tprint \\\"missed ack\\\"\\n\\t\\t\\t\\ttime.sleep(0.55)\\n\\n\\n\\t\\t\\t# inner loop: runs from button press until packet received.\\n\\t\\t\\twhile buffer_info[0] < nSamples:\\n\\n\\t\\t\\t\\t# button press\\n\\t\\t\\t\\tif last_packet_handled and ready_for_next_button_press:\\n\\t\\t\\t\\t\\t# we can send the next packet because the last packet was handled (received or understood to be missed)\\n\\t\\t\\t\\t\\t# and instruments are configured\\n\\t\\t\\t\\t\\t# button press -> set value on enabled AD2 output pins (digital_out_channels_bits)\\n\\t\\t\\t\\t\\t# AD2 output is hard wired to button press input which triggers acquisition\\n\\n\\t\\t\\t\\t\\t#get current value of packet_received_pin; when packet is received this will toggle\\n\\t\\t\\t\\t\\tcurr_DIO = self._get_DIO_values()\\n\\t\\t\\t\\t\\tpacket_received_pins_state = curr_DIO & self.packet_received_bits\\n\\t\\t\\t\\t\\tpacket_created_pin_state = curr_DIO & self.packet_created_bit\\n\\n\\t\\t\\t\\t\\tlast_packet_handled = False\\n\\t\\t\\t\\t\\tready_for_next_button_press = False\\n\\t\\t\\t\\t\\tpacket_received = False\\n\\t\\t\\t\\t\\tack_missed = False\\n\\n\\t\\t\\t\\t\\t# press the button. all other outputs go low.\\n\\t\\t\\t\\t\\tdwf.FDwfDigitalIOOutputSet(self.interface_handler, c_uint16(self.button_press_bit))\\n\\t\\t\\t\\t\\t#reset all enabled digital out channels back to steady state (all high except button press)\\n\\t\\t\\t\\t\\tdwf.FDwfDigitalIOOutputSet(self.interface_handler, steady_state_DIO)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#print \\\"button pressed\\\"\\n\\t\\t\\t\\t\\tnum_tries += 1\\n\\n\\t\\t\\t\\t# copy buffer samples to memory and flush\\n\\t\\t\\t\\t#print \\\"Before: {}\\\".format(buffer_info)\\n\\t\\t\\t\\tbuffer_info = self._copy_buffer_samples(buffer_info, nSamples, rgwSamples)\\n\\t\\t\\t\\t#print \\\"After: {}\\\".format(buffer_info)\\n\\t\\t\\t\\t#buffer_flush_stop = time.clock()\\n\\n\\t\\t\\t\\tcurr_csamples = buffer_info[0]\\n\\t\\t\\t\\tif curr_csamples == prev_csamples:\\n\\t\\t\\t\\t\\tprint \\\"broke early\\\"\\n\\t\\t\\t\\t\\tnum_tries -= 1\\n\\t\\t\\t\\t\\tbroke_early = True\\n\\n\\t\\t\\t\\t\\t# stop sampling\\n\\t\\t\\t\\t\\tdwf.FDwfDigitalInConfigure(self.interface_handler, c_bool(0), c_bool(0))\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t# manually stop sampling once packet_received_bit is not equal to its pin state\\n\\t\\t\\t\\tcurr_DIO = self._get_DIO_values()\\n\\t\\t\\t\\tif ((curr_DIO & self.packet_received_bits) != packet_received_pins_state):\\n\\t\\t\\t\\t\\t#copy last buffer samples to memory\\n\\t\\t\\t\\t\\tbuffer_info = self._copy_buffer_samples(buffer_info, nSamples, rgwSamples, last_read=True)\\n\\n\\t\\t\\t\\t\\t# packet_received_bit toggled; stop sampling\\n\\t\\t\\t\\t\\tdwf.FDwfDigitalInConfigure(self.interface_handler, c_bool(0), c_bool(0))\\n\\n\\t\\t\\t\\t\\tcurr_DIO = self._get_DIO_values()\\n\\t\\t\\t\\t\\tif (curr_DIO & self.packet_created_bit) != packet_created_pin_state:\\n\\t\\t\\t\\t\\t\\tack_missed = True\\n\\n\\t\\t\\t\\t\\tpacket_received = True\\n\\t\\t\\t\\t\\tnum_packets_received += 1\\n\\t\\t\\t\\t\\t#print \\\"received packet {}\\\".format(num_tries)\\n\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\tprev_csamples = curr_csamples\\n\\t\\t\\t\\t# end of the inner loop\\n\\n\\t\\t\\t#set this so we can push button again\\n\\t\\t\\tlast_packet_handled = True\\n\\n\\t\\t\\tif broke_early:\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t# reach here if packet was received OR if 1.5 million samples have been taken\\n\\t\\t\\tif packet_received == True:\\n\\t\\t\\t\\tself.postprocess(num_tries, buffer_info, rgwSamples, data_file)\\n\\n\\t\\t\\telse:\\n\\t\\t\\t\\t# we took 1.5 million samples and supposedly missed the packet\\n\\t\\t\\t\\tnum_packets_missed += 1\\n\\t\\t\\t\\tpacket_number_missed.append(num_tries)\\n\\t\\t\\t\\tself.postprocess(num_tries, buffer_info, rgwSamples, data_file, missed_packet=True)\\n\\t\\t\\t\\t# set last_packet_handled to True to try button press again\\n\\n\\n\\t\\trun_end_timestamp = time.clock()\\n\\t\\tprint \\\"Done with experiment\\\"\\n\\t\\t#print all packets sent, lost, total info\\n\\t\\tprint \\\"Number of tries: {}\\\".format(num_tries)\\n\\t\\tprint \\\"Number of received packets: {}\\\".format(num_packets_received)\\n\\t\\tprint \\\"Number of missed packets: {}\\\\n\\\".format(num_packets_missed)\\n\\t\\tprint \\\"Total duration: {} seconds\\\".format(run_end_timestamp - run_start_timestamp)\\n\\t\\treturn\",\n \"def get_data():\\n \\n data = {\\n 'loadAvg1Min': 0, #load average 1 min\\n 'loadAvg5Min': 0, #load average 5 min\\n 'loadAvg15Min': 0, #load average 15 min\\n 'cpuUsage': [], #usage distribution for each cpu\\n 'memUsage': {}, #memory usage \\n 'networkReads': [], #network reads per second for each interface\\n 'networkWrites': [], #network writes per second for each interface\\n 'diskReads': [], #disk reads per second for each disk\\n 'diskWrites': [] #disk writes per second for each disk\\n }\\n \\n #metrics that doesnt need sampling\\n data['loadAvg1Min'], data['loadAvg5Min'], data['loadAvg15Min'] = get_load_avg() #get load avg\\n data['memUsage'].update(get_mem_usage()) #memory usage\\n \\n #metrics that needs sampling\\n #they are written as a generator so that we can sleep before collection again\\n sampling_duration = 1\\n cpu_usage_gen = get_cpu_usage(sampling_duration) #generator for cpu usage\\n net_rw_gen = get_net_rw(sampling_duration) #generator for network read write\\n disk_rw_gen = get_disk_rw(sampling_duration) #generator for disk read write\\n \\n while 1: #now start sampling, whenever we have walid data, we can exit the loop\\n cpu_usage = next(cpu_usage_gen)\\n net_rw = next(net_rw_gen)\\n disk_rw = next(disk_rw_gen)\\n \\n if cpu_usage or net_rw or disk_rw: #we have valid data\\n break\\n \\n time.sleep(sampling_duration)\\n \\n #append cpu usage for each cpu core\\n for cpu, usage in cpu_usage.items():\\n data['cpuUsage'].append({'name': cpu, 'value': usage})\\n \\n #append network read and write for each interface\\n for interface, rw in net_rw.items():\\n data['networkReads'].append({'name': interface, 'value': rw['reads']})\\n data['networkWrites'].append({'name': interface, 'value': rw['writes']}) \\n \\n #append disk read and write for each logical disk\\n for device, rw in disk_rw.items():\\n data['diskReads'].append({'name': device, 'value': rw['reads']})\\n data['diskWrites'].append({'name': device, 'value': rw['writes']})\\n \\n return data\",\n \"def collect_samples(serialPort,NO_SENSORS,NO_SAMPLES,log):\\n run = '1'\\n badSamples = 0\\n count = 1\\n log_temp = []\\n temp = [0] * 20\\n NO_FIELDS = (NO_SENSORS * 3) + 1\\n \\n while (run == '1'):\\n # If the input buffer is not empty read the data out into rawData using \\\\n as a delimiter.\\n if (serialPort.inWaiting()>0):\\n rawData = serialPort.readline()\\n print(rawData)\\n \\n # If invalid data is recieved this prevents program crash\\n try:\\n # Decode the bytes into a string\\n data = rawData.decode()\\n \\n # Split x, y, z and newline values into a list\\n if (count >= (NO_SAMPLES + 1)):\\n endTime_temp = data.split(\\\" \\\", 2)\\n if (len(endTime_temp) == 2 and '' not in endTime_temp):\\n endTime = int(endTime_temp[0])\\n else:\\n endTime = 780\\n print('Time not recieved')\\n print('Lost Samples: ' + str(badSamples))\\n run = '0'\\n else:\\n data_readings = data.split(\\\" \\\", NO_FIELDS)\\n print(data_readings)\\n \\n # A correct sample should contain 16 values and not include null and so this is used\\n # to validate the data and record any samples that are discarded in this way\\n if (len(data_readings) == NO_FIELDS and '' not in data_readings):\\n # Discard newline characters before saving data\\n int_data_readings = list(map(int,data_readings[:(NO_FIELDS - 1)]))\\n log_temp.append(int_data_readings)\\n else:\\n badSamples += 1\\n except:\\n print('Invalid data recieved')\\n \\n count += 1\\n\\n samplingPeriod = (endTime/NO_SAMPLES)/NO_SENSORS\\n timeStamp = 0.0\\n\\n for i in range(0,len(log_temp)):\\n for j in range(0,NO_SENSORS):\\n temp[0+(j*4)] = log_temp[i][0+(j*3)]\\n temp[1+(j*4)] = log_temp[i][1+(j*3)]\\n temp[2+(j*4)] = log_temp[i][2+(j*3)]\\n temp[3+(j*4)] = timeStamp\\n timeStamp += samplingPeriod\\n log.append(temp.copy())\",\n \"def sample_record(self, chunkdata):\\n version = chunkdata[0:4]\\n if version == V6_VERSION:\\n record_size = self.v6_struct.size\\n elif version == V5_VERSION:\\n record_size = self.v5_struct.size\\n elif version == V4_VERSION:\\n record_size = self.v4_struct.size\\n elif version == V3_VERSION:\\n record_size = self.v3_struct.size\\n else:\\n return\\n\\n for i in range(0, len(chunkdata), record_size):\\n if self.sample > 1:\\n # Downsample, using only 1/Nth of the items.\\n if random.randint(0, self.sample - 1) != 0:\\n continue # Skip this record.\\n\\n record = chunkdata[i:i + record_size]\\n # for earlier versions, append fake bytes to record to maintain size\\n if version == V3_VERSION:\\n # add 16 bytes of fake root_q, best_q, root_d, best_d to match V4 format\\n record += 16 * b'\\\\x00'\\n if version == V3_VERSION or version == V4_VERSION:\\n # add 12 bytes of fake root_m, best_m, plies_left to match V5 format\\n record += 12 * b'\\\\x00'\\n # insert 4 bytes of classical input format tag to match v5 format\\n record = record[:4] + CLASSICAL_INPUT + record[4:]\\n if version == V3_VERSION or version == V4_VERSION or version == V5_VERSION:\\n # add 48 byes of fake result_q, result_d etc\\n record += 48 * b'\\\\x00'\\n\\n if version == V6_VERSION:\\n # diff focus code, peek at best_q, orig_q and pol_kld from record (unpacks as tuple with one item)\\n best_q = struct.unpack('f', record[8284:8288])[0]\\n orig_q = struct.unpack('f', record[8328:8332])[0]\\n pol_kld = struct.unpack('f', record[8348:8352])[0]\\n\\n # if orig_q is NaN or pol_kld is 0, accept, else accept based on diff focus\\n if not np.isnan(orig_q) and pol_kld > 0:\\n diff_q = abs(best_q - orig_q)\\n q_weight = self.diff_focus_q_weight\\n pol_scale = self.diff_focus_pol_scale\\n total = (q_weight * diff_q + pol_kld) / (q_weight +\\n pol_scale)\\n thresh_p = self.diff_focus_min + self.diff_focus_slope * total\\n if thresh_p < 1.0 and random.random() > thresh_p:\\n continue\\n\\n yield record\",\n \"def sample(self, length):\\n pass\",\n \"def sample(self, size=1):\\n raise NotImplementedError\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6005613","0.5774641","0.5711628","0.5686355","0.56711054","0.56303364","0.5627739","0.56075263","0.55885583","0.55885583","0.55640453","0.5494687","0.54919183","0.54767716","0.5444199","0.5424295","0.5424295","0.5423679","0.54222864","0.5411638","0.5382132","0.53792113","0.53764224","0.53743637","0.53689384","0.5363429","0.53607094","0.53535354","0.5339893","0.53375685","0.5326297","0.5324601","0.5315998","0.5313697","0.5301164","0.5290884","0.52890104","0.5271228","0.5267801","0.52593726","0.5249","0.5239635","0.5221685","0.52163446","0.51891965","0.51845133","0.51761055","0.5166004","0.5152889","0.5142826","0.51423305","0.5139295","0.5136963","0.51359123","0.512666","0.5124476","0.51219267","0.5114632","0.51122594","0.5111255","0.51085746","0.5107183","0.5106482","0.51048434","0.5096397","0.5094716","0.5091812","0.50915796","0.50773776","0.50718915","0.50678766","0.5057747","0.5044481","0.5041574","0.5035357","0.50292003","0.50238436","0.50216144","0.501797","0.5015903","0.5015403","0.5014925","0.50118047","0.5008561","0.50054324","0.5002143","0.49983618","0.49884546","0.49881384","0.49858707","0.49820897","0.49806124","0.49774224","0.4971904","0.496223","0.49603087","0.49577937","0.49570948","0.4953891","0.49495414","0.49477878"],"string":"[\n \"0.6005613\",\n \"0.5774641\",\n \"0.5711628\",\n \"0.5686355\",\n \"0.56711054\",\n \"0.56303364\",\n \"0.5627739\",\n \"0.56075263\",\n \"0.55885583\",\n \"0.55885583\",\n \"0.55640453\",\n \"0.5494687\",\n \"0.54919183\",\n \"0.54767716\",\n \"0.5444199\",\n \"0.5424295\",\n \"0.5424295\",\n \"0.5423679\",\n \"0.54222864\",\n \"0.5411638\",\n \"0.5382132\",\n \"0.53792113\",\n \"0.53764224\",\n \"0.53743637\",\n \"0.53689384\",\n \"0.5363429\",\n \"0.53607094\",\n \"0.53535354\",\n \"0.5339893\",\n \"0.53375685\",\n \"0.5326297\",\n \"0.5324601\",\n \"0.5315998\",\n \"0.5313697\",\n \"0.5301164\",\n \"0.5290884\",\n \"0.52890104\",\n \"0.5271228\",\n \"0.5267801\",\n \"0.52593726\",\n \"0.5249\",\n \"0.5239635\",\n \"0.5221685\",\n \"0.52163446\",\n \"0.51891965\",\n \"0.51845133\",\n \"0.51761055\",\n \"0.5166004\",\n \"0.5152889\",\n \"0.5142826\",\n \"0.51423305\",\n \"0.5139295\",\n \"0.5136963\",\n \"0.51359123\",\n \"0.512666\",\n \"0.5124476\",\n \"0.51219267\",\n \"0.5114632\",\n \"0.51122594\",\n \"0.5111255\",\n \"0.51085746\",\n \"0.5107183\",\n \"0.5106482\",\n \"0.51048434\",\n \"0.5096397\",\n \"0.5094716\",\n \"0.5091812\",\n \"0.50915796\",\n \"0.50773776\",\n \"0.50718915\",\n \"0.50678766\",\n \"0.5057747\",\n \"0.5044481\",\n \"0.5041574\",\n \"0.5035357\",\n \"0.50292003\",\n \"0.50238436\",\n \"0.50216144\",\n \"0.501797\",\n \"0.5015903\",\n \"0.5015403\",\n \"0.5014925\",\n \"0.50118047\",\n \"0.5008561\",\n \"0.50054324\",\n \"0.5002143\",\n \"0.49983618\",\n \"0.49884546\",\n \"0.49881384\",\n \"0.49858707\",\n \"0.49820897\",\n \"0.49806124\",\n \"0.49774224\",\n \"0.4971904\",\n \"0.496223\",\n \"0.49603087\",\n \"0.49577937\",\n \"0.49570948\",\n \"0.4953891\",\n \"0.49495414\",\n \"0.49477878\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12889,"cells":{"query":{"kind":"string","value":"Get baseline data without treatment time courses"},"document":{"kind":"string","value":"def baseline(self):\n return self.data[self.data['treatment'] == 'Baseline']"},"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 emissions_baseline(self):\n baseline = DataFrame(columns=[\"CO2\", \"NOx\", \"PM10\", \"PM2.5\", \"SO2\"])\n baseline = baseline.append(year_1(self.plant.emissions()))\n baseline = baseline.append(year_1(self.plant.fuel_reseller().emissions()))\n baseline = baseline.append(year_1(self.farmer.emissions_exante))\n baseline.loc[\"Total\"] = baseline.sum()\n baseline.loc[\"Total_plant\"] = baseline.iloc[0]\n baseline.loc[\"Total_transport\"] = baseline.iloc[1]\n baseline.loc[\"Total_field\"] = baseline.iloc[2]\n return baseline","def baseline(self) -> List[PredictionsDatapoints]:\n return self._baseline","def organise_baseline_data(self):\n self.baseline_data = {}\n for injkey in self.data_sets.keys():\n data = {}\n baseline_result = self.data_sets[injkey].pop('full_syst_baseline')\n datakey = baseline_result.keys()[0]\n baseline_data = self.systtest_fit_extract(\n fit_data=baseline_result[datakey],\n datakey=datakey,\n labels=self.labels[injkey]['full_syst_baseline'].dict\n )\n self.baseline_data[injkey] = baseline_data","def baselineFrames(self):\n frames=[]\n for tag,T1,T2 in [x for x in self.tags if x[0]=='baseline']:\n for i,timePoint in enumerate(self.conf['times']):\n if timePoint>=T1*60 and timePoint<=T2*60:\n frames.append(i)\n return frames\n else:\n return [0]","def baseline(x_data, y_data, stra = \"uniform\"):\r\n x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.2)\r\n dummy = DummyClassifier(strategy= stra)\r\n dummy.fit(x_train, y_train)\r\n y_pred = dummy.predict(x_test)\r\n accu = accuracy_score(y_test, y_pred)\r\n return accu","def __getBaselineList(self):\n\n # cumulative baseline selections do not reflect on the msselectedindices()\n if self._msTool is None:\n self.__selectMS()\n\n \n # If there are any previous antenna selections, use it\n if self._arg['antenna'] != '':\n baselineSelection = {'baseline':self._arg['antenna']}\n try:\n self._msTool.msselect(baselineSelection, onlyparse=False)\n # IMPORTANT: msselectedindices() will always say there are auto-correlation\n # baselines, even when there aren't. In the MMS case, the SubMS creation will\n # issue a MSSelectionNullSelection and not be created. \n baselinelist = self._msTool.msselectedindices()['baselines']\n except:\n baselinelist = []\n else:\n md = msmdtool()\n md.open(self._arg['vis'])\n baselines = md.baselines()\n md.close()\n import numpy as np\n baselinelist = np.vstack(np.where(np.triu(baselines))).T \n \n\n return baselinelist.tolist()","def getDataForLoadComparisons(self):\n\n\t\t# Variables\n\t\tload_data = self.getLoadData() \n\t\tvalues = [] \n\t\tinner_dict = {}\n\t\touter_dict = {}\n\t\tfinal_data = []\n\t\tyesterday = self.helper.getYesterday()\n\t\tkey = self.helper.getYear() + self.helper.getMonth() + self.helper.getDay() + \"-loadData\"\n\t\tdata = load_data[yesterday[0]][int(yesterday[1])][int(yesterday[2])]\n\t\tdates = (['12:00 AM','1:00 AM','2:00 AM','3:00 AM','4:00 AM','5:00 AM',\n\t\t\t'6:00 AM','7:00 AM','8:00 AM','9:00 AM','10:00 AM','11:00 AM',\n\t\t\t'12:00 PM','1:00 PM','2:00 PM','3:00 PM','4:00 PM','5:00 PM',\n\t\t\t'6:00 PM','7:00 PM','8:00 PM','9:00 PM','10:00 PM','11:00 PM'])\n\n\t\t# Populating values array\n\t\tfor i in range(0,len(data)):\n\t\t\tinner_dict['label'] = dates[i]\n\t\t\tinner_dict['value'] = data[i]\n\t\t\tvalues.append(inner_dict)\n\t\t\tinner_dict = {}\n\n\t\t# Populating the final_data array and returning it\n\t\touter_dict['key'] = key\n\t\touter_dict['values'] = values\n\t\tfinal_data.append(outer_dict)\n\n\t\treturn final_data","def calculate_ddct(self, baseline_time=0):\n\n if baseline_time == 0:\n baseline = self.baseline_data['dct'][0]\n\n elif baseline_time == 96:\n baseline = self.baseline_data['dct'][96]\n\n elif baseline_time == 'average':\n baseline = (self.baseline_data['dct'][0] + self.baseline_data['dct'][96]) / 2\n\n control =self.treatment_data.query('treatment == \"Control\"')['dct']\n tgf = self.treatment_data.query('treatment == \"TGFb\"')['dct']\n control.index = control.index.droplevel(1)\n tgf.index = tgf.index.droplevel(1)\n baseline.index = baseline.index.droplevel(1)\n\n time = control.columns\n\n tgf = pandas.concat([tgf[i]/baseline for i in tgf.columns], axis=1)\n control = pandas.concat([control[i]/baseline for i in control.columns], axis=1)\n\n control.columns = time\n tgf.columns = time\n\n control = pandas.DataFrame(control.stack())\n tgf = pandas.DataFrame(tgf.stack())\n control['treatment'] = 'Control'\n tgf['treatment'] = 'TGFb'\n df = pandas.concat([control, tgf]).reset_index()\n df.rename(columns={0: 'ddct'})\n return df","def test_get_derived_metric_history(self):\n pass","def get_iaq_baseline(self) -> List[int]:\n # name, command, signals, delay\n return self._run_profile((\"iaq_get_baseline\", [0x20, 0x15], 2, 0.01))","def data_preprocessing(dataset):\r\n df = pd.read_csv(dataset)\r\n df.head()\r\n df.describe()\r\n df.isnull().sum()\r\n df= df.drop(['instant'], axis=1)\r\n df['dteday'] = pd.to_datetime(df['dteday'].apply(str) + ' ' + df['hr'].apply(str) + ':00:00')\r\n return df","def get_timecourse_data(self, fragment, number):\n timepoints = self.get_timepoints()\n timecourse = []\n for time in timepoints:\n if self.mdvtc[time].has_data(fragment, number):\n ratio, stdev, use = self.mdvtc[time].get_data(fragment, number)\n timecourse.append(ratio)\n return timecourse","def baseline(records, baseline_samples=40):\n if not len(records):\n return\n samples_per_record = len(records[0]['data'])\n\n # Array for looking up last baseline seen in channel\n # We only care about the channels in this set of records; a single .max()\n # is worth avoiding the hassle of passing n_channels around\n last_bl_in = np.zeros(records['channel'].max() + 1, dtype=np.int16)\n\n for d_i, d in enumerate(records):\n\n # Compute the baseline if we're the first record of the pulse,\n # otherwise take the last baseline we've seen in the channel\n if d.record_i == 0:\n bl = last_bl_in[d.channel] = d.data[:baseline_samples].mean()\n else:\n bl = last_bl_in[d.channel]\n\n # Subtract baseline from all data samples in the record\n # (any additional zeros should be kept at zero)\n last = min(samples_per_record,\n d.pulse_length - d.record_i * samples_per_record)\n d.data[:last] = int(bl) - d.data[:last]\n d.baseline = bl","def calc_baseline(signal):\n ssds = np.zeros((3))\n\n cur_lp = np.copy(signal)\n iterations = 0\n while True:\n # Decompose 1 level\n lp, hp = pywt.dwt(cur_lp, \"db4\")\n\n # Shift and calculate the energy of detail/high pass coefficient\n ssds = np.concatenate(([np.sum(hp ** 2)], ssds[:-1]))\n\n # Check if we are in the local minimum of energy function of high-pass signal\n if ssds[2] > ssds[1] and ssds[1] < ssds[0]:\n break\n\n cur_lp = lp[:]\n iterations += 1\n\n # Reconstruct the baseline from this level low pass signal up to the original length\n baseline = cur_lp[:]\n for _ in range(iterations):\n baseline = pywt.idwt(baseline, np.zeros((len(baseline))), \"db4\")\n\n return baseline[: len(signal)]","def baseline(data):\n weights = weighting(data)\n return np.inner(weights,data['clicks'])/weights.sum()","def graph_baseline(evictiondata, weeks):\r\n base_evictions_per_week = {}\r\n for index, row in evictiondata.iterrows():\r\n if row['week_date'] not in base_evictions_per_week.keys():\r\n base_evictions_per_week[row['week_date']] = row['filings_avg']\r\n elif row['GEOID'] != 'sealed':\r\n base_evictions_per_week[row['week_date']] += row['filings_avg']\r\n base_evictions_filed = []\r\n for week in weeks:\r\n base_evictions_filed.append(base_evictions_per_week[week])\r\n\r\n plt.figure(figsize=(50, 10))\r\n plt.plot(weeks, base_evictions_filed, color='orange')\r\n plt.title('Base Evictions filed by the week')\r\n plt.xlabel('Date')\r\n plt.ylabel('Evictions filed')\r\n plt.show()\r\n return base_evictions_filed","def _load_timecourses(self):\n # load the timecourses file\n tcsf = fetch_one_file(self.ica_dir, self._tcs_fname)\n tcs = niimg.load_img(tcsf).get_data()\n return tcs","def test_no_base_date(self):\n data = self._data()\n data.pop('base_date')\n steps = [{'dateTime': '2012-06-07', 'value': '10'}]\n TimeSeriesData.objects.create(\n user=self.user,\n resource_type=TimeSeriesDataType.objects.get(\n category=TimeSeriesDataType.activities, resource='steps'),\n date=steps[0]['dateTime'],\n value=steps[0]['value']\n )\n response = self._mock_utility(response=steps, get_kwargs=data)\n self._check_response(response, 100, steps)","def process_for_baseline(dat):\n records = []\n count = 0\n for record in dat:\n # Context\n context = record['context'].replace(\"''\", '\" ').replace(\"``\", '\" ') # Replace non-standard quotation marks\n context_tokens = text2tokens(context)\n spans = convert_idx(context, context_tokens) # (token_start_char_idx, token_end_char_idx)\n \n # Question\n ques = record['question'].replace(\"''\", '\" ').replace(\"``\", '\" ') \n ques_tokens = text2tokens(ques)\n \n # Answers\n y1, y2 = charIdx_to_tokenIdx(spans, record['answers']['text'], record['answers']['answer_start']) \n\n res_dict = {\"context_tokens\": context_tokens,\n \"ques_tokens\": ques_tokens,\n \"answer\": record['answers']['text'], \n \"y1s\": y1, \n \"y2s\": y2,\n \"id\": count,\n 'pubId': record['PubID'],\n \"group\": record['group']}\n records.append(res_dict)\n count += 1 \n \n return records","def baseline_statistics(self, **_):\n raise NotImplementedError(\"{} doesn't support statistics.\".format(__class__.__name__))","def all_data(self):\n return pd.concat([self.historic_data, self.dayahead_data])","def _read_baseline(self, path):\n base_rmsd = dict()\n fin = open(path,'r')\n for line in fin:\n if line == '\\s' or line == '' or line == '\\n':\n continue\n k, v = line.split()\n base_rmsd[k.strip()] = float(v.strip())\n return base_rmsd","def _load_timecourses(self):\n # load the timecourses file\n tcsf = fetch_one_file(self.ica_dir, self._tcs_fname, pat_type='re.match')\n tcs = niimg.load_img(tcsf).get_data()\n return tcs","def run_baseline_simulation(self):\n n_days_base = 1 # Only consider 1 day simulation, self.n_days_base\n sim_time = 24*3600 # one day in seconds\n \n print(\"Running day-ahead baseline simulation ...\") \n print(\"Running baseline right away charging strategy ...\")\n baseline_soc, baseline_std_soc, baseline_power, baseline_cycles, baseline_Tin, baseline_std_Tin, baseline_Tin_max, baseline_Tin_min = self.run_baseline_right_away(n_days_base, sim_time)\n \n print(\"Exported baseline soc, Temperatures, power and HVAC cycles ...\")\n \n base_path = dirname(abspath(__file__))\n path = join(base_path,'data')\n \n # Already saved inside the right away function\n # baseline_soc.to_csv(join(path, r'SOC_baseline.csv'), index = False)\n # baseline_power.to_csv(join(path, r'power_baseline.csv'), index = False)\n # baseline_Tin.to_csv(join(path, r'Tin_baseline.csv'), index = False)\n # baseline_Tin_max.to_csv(join(path, r'Tin_max_baseline.csv'), index = False)\n # baseline_Tin_min.to_csv(join(path, r'Tin_min_baseline.csv'), index = False)\n print(\"Exported\")","def baseline(spectra):\n\n return spectra - np.mean(spectra, axis=0)","def _baseline_value(self):\n t = self['primary']\n return np.median(t.data[:int(10e-3/t.dt)])","def read_ct_data(train_start, train_count, eval_start, eval_count):\n data = pd.read_csv('/opt/train.csv')\n\n # Dropping the id column\n data.drop(['ID_code'], axis=1, inplace=True)\n\n data = data.values\n return (data[train_start:train_start + train_count],\n data[eval_start:eval_start + eval_count])","def data(self):\n if self._data.empty:\n self._data = super().data\n\n max_data_year = self._data[\"year\"].max()\n\n # If the date range of the data doesn't line up with the year filters\n # for train/test data, we risk getting empty data sets\n if self.max_year != max_data_year:\n max_year_diff = pd.to_timedelta(\n [(YEAR_IN_DAYS * (self.max_year - max_data_year))]\n * len(self._data),\n unit=\"days\",\n )\n\n self._data.loc[:, \"date\"] = self._data[\"date\"] + max_year_diff\n self._data.loc[:, \"year\"] = self._data[\"date\"].dt.year\n self._data.set_index(\n [\"team\", \"year\", \"round_number\"], drop=False, inplace=True\n )\n\n return self._data","def background_subtract_data(data):\n bgsub_data = data.copy()\n bax_concs = data.columns.levels[0]\n lipo_concs = data.columns.levels[1]\n\n for bax_conc in data.columns.levels[0]:\n timecourses = data.xs(bax_conc, axis=1, level='Bax')\n bg = timecourses[0.]\n for lipo_conc in lipo_concs:\n bgsub_tc = timecourses[lipo_conc] - bg\n bgsub_data[(bax_conc, lipo_conc)] = bgsub_tc\n\n return bgsub_data","def calc_base_year_data(base_year_vehicles_df):\n pass","def test_get_all_derived_metrics(self):\n pass","def treatments(self):\n return self.data[self.data['treatment'] != 'Baseline']","def persistence_baseline(d, mode='test'):\n y = getattr(d, mode + \"Y\")\n preds = shift(y, 1, cval=0.0)\n return (get_mse(d, preds, mode), get_mae(d, preds, mode),\n get_mape(d, preds, mode))","def _get_majority_baseline(self) -> np.ndarray:\n\n self._majority_label = max(set(self.y_training_set_all_),\n key=self.y_training_set_all_.count)\n return np.array([self._majority_label]*len(self.y_training_set_all_))","def evalBaseline(self, df = None):\n \n if (df is None):\n self.r_b = self.df.merge(self.df_user[[\"user ind\", \"b_u\"]], on = \"user ind\")\n self.r_b = self.r_b.merge(self.df_item[[\"item ind\", \"b_i\"]], on = \"item ind\")\n self.r_b[\"baseline\"] = self.r_mean + self.r_b[\"b_u\"] + self.r_b[\"b_i\"]\n \n \n return self.r_b[[\"user id\", \"item id\", \"baseline\"]]\n \n else:\n df = df.merge(self.df_user, on = \"user id\").merge(self.df_item, on = \"item id\")\n df[\"baseline\"] = self.r_mean + df[\"b_u\"] + df[\"b_i\"]\n \n # clip the score to the interval [1, 5]\n df[\"baseline\"] = np.minimum(np.maximum(df[\"baseline\"], 1), 5)\n \n return df[[\"user id\", \"item id\", \"baseline\"]]","def history(self, t_minus=0):\n data = self.ohlcv_df[self.ohlcv_df.index <= utc_to_epoch(\n self.prior_time)]\n return OHLCVData(data[-t_minus:])","def _get_raw_data(self, idx=0):\n # Get the time step then make a data frame\n raise NotImplementedError('Code me up!')\n #data = self._data[???]\n return data","def async_baseline(kwargs):\n # we can't pickle our objects for remote works so we pickle the raw request\n # and then load it here.\n data = baseline_input_schema.load(kwargs).data\n return baseline(**data)","def get_data(t_idx):\n train_data = []\n train_label = []\n valid_data = []\n valid_label = []\n test_data = []\n test_label = []\n \n lines = []\n #f = open('/home/liwenzhe/myworkspace/is13/dataset/closingAdjLog.csv', 'rb')\n f = open('dataset/closingAdjLog.csv')\n reader = csv.reader(f)\n for row in reader:\n lines.append(row)\n lines.pop(0)\n \n n = len(lines)\n # use the first 80% for the training data, the next 10% for the validation data\n # and the last 10% for the test data. \n # TODO : create folds instead. \n for i in xrange(n-1, -1, -1):\n curr_line = lines[i]\n if i > n * 0.2:\n # add into training data\n if t_idx == 0:\n train_data.append(curr_line[t_idx+1:])\n else:\n train_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\n train_label.append(curr_line[t_idx]) \n elif i > n * 0.1:\n # add into validation data\n if t_idx == 0:\n valid_data.append(curr_line[t_idx+1:])\n else: \n valid_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\n valid_label.append(curr_line[t_idx]) \n else:\n # add into test data\n if t_idx == 0:\n test_data.append(curr_line[t_idx+1:])\n else:\n test_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\n test_label.append(curr_line[t_idx]) \n \n return [train_data, train_label, valid_data, valid_label, test_data, test_label]","def _calculate(self):\n source = self.source\n res = {}\n l_cols = [[], [], [], []]\n r_lines = {}\n dateline=None\n ###delete the below code when fetch data from database(assume: data in database has been pretreatment)\n if source[t.ror].min() > -99.0:\n pass\n else:\n source[t.ror] = np.where(\n source[t.ror] > -99.0, source[t.ror], -99.0)\n ###\n for account in self.accounts:\n source_account = source[source[t.account] == account]\n source_account = source_account.reset_index(drop=True)\n dateline=source_account[t.effective_date]\n ror=source_account[t.ror]/100\n returns_cum = ROR.ror_cum_ann(source_account, self.annualized)\n # double_return_cum=round(double_return_cum,2)+1\n returns_cum = returns_cum + 1\n growth_amounts = returns_cum * self.starting_value\n returns_cum, growth_amounts = round(returns_cum - 1, 4), \\\n round(growth_amounts, 2)\n l_cols[0].append(growth_amounts.iloc[-1, 0])#account growth amount\n l_cols[1].append(growth_amounts.iloc[-1, 1])#bench growth amount\n l_cols[2].append(returns_cum.iloc[-1, 0])#account return\n l_cols[3].append(returns_cum.iloc[-1, 1])#bench return\n r_lines[account] = [list(returns_cum.iloc[:,0]), list(growth_amounts.iloc[:, 0]),#list(returns_cum.iloc[:, 0])\n list(growth_amounts.iloc[:, 1])]#account return, account growth amount, bench growth amount\n res['account_vs_benchmark'] = {'xAxis': self.accounts,\n 'series': l_cols}\n res['growth_of_unit'] = {'xAxis': list(dateline),\n 'series': r_lines}\n return res\n # ret_dict = self._ret(accounts, starting_value, source, annualized)\n # return ret_dict","def get_year_uncertainty(bm, num):\n am_in_use = pd.DataFrame()\n am_waste = pd.DataFrame()\n am_total = pd.DataFrame()\n y_in_use = np.empty(0)\n y_total = np.empty(0)\n for j in xrange(num):\n tmp = get_AM_by_factor()\n am_in_use[j] = tmp['in-use']\n am_waste[j] = tmp['waste']\n am_total[j] = tmp['in-use'] + tmp['waste']\n bm_rand = bm.iloc[j, :]\n # For each random couple of timelines - of Biomass and Anthropogenic mass - find the time of intersection and append to array \n y_in_use = np.append(y_in_use, intersection_time(bm_rand, am_in_use[j]))\n y_total = np.append(y_total, intersection_time(bm_rand, am_total[j]))\n return am_in_use, am_waste, am_total, y_in_use, y_total","def baseline(*args):\n XTrain, XTest, yTrain, yTest = args\n clf = DecisionTreeClassifier(random_state=42)\n clf.fit(XTrain, yTrain)\n return clf.score(XTest, yTest), clf.feature_importances_","def _getBaselineThresh(self):\n print('Calculating 10% baseline')\n self.baseline = obrienBaseline.obrienBaseline(\n self.d['dos1rate'], timeWidth=5.0, \n cadence=0.1)\n self.peak_std = ( (self.d['dos1rate'][self.peakInd]/10 - \n self.baseline[self.peakInd]/10)/ \n np.sqrt(self.d['dos1rate'][self.peakInd]/10))\n return","def baseline(dataset: Dataset, conf: Namespace) -> np.ndarray:\n\n print(\"Calibrating global scores...\")\n # Copy dataset dataframe and set up the score and test columns\n df = dataset.df.copy()\n df['test'] = df['fold'] == dataset.fold\n df['score'] = df[dataset.feature]\n\n # Extract score and ground truth of train set\n score = df[ df['test'] == False ][ 'score' ].to_numpy()\n ground_truth = df[ df['test'] == False ][ 'same' ].to_numpy(dtype=int)\n\n # Set up calibrator on train set\n calibrator = BetaCalibration(scores=score,\n ground_truth=ground_truth,\n score_min=-1,\n score_max=1,\n )\n\n # Run calibrator on all data\n return calibrator.predict(df['score'])","def getMeasures():","def mean_baseline(self):\n train_mean = np.mean(self.data.loc[self.train_index, self.target_name])\n rmse = np.sqrt(\n np.mean(np.square(self.data.loc[self.test_index, self.target_name] - train_mean)))\n print 'mean baseline RMSE: {}'.format(rmse)","def year_absolute_baseline_difference_rule(_m, y):\r\n\r\n return m.z_b1[y] + m.z_b2[y]","def year_absolute_baseline_difference_rule(_m, y):\r\n\r\n return m.z_b1[y] + m.z_b2[y]","def get_perf(self) :\n self.train()\n self.df_true = self.df_true[self.length:]\n self.accuracy , self.recall, self.specificity, self.profit, self.min , self.max = get_accuracy_LSTM(self.df_test, self.df_true,self.model, self.length)","def baseline_total_organic_compound(self):\n return self.indoor_air_quality_baseline[1]","def yearly(self):\r\n return RecordsYearly(self)","def get_data(dataset, **kwargs):\n age_df = load_age_sample_from_mcmc_chains(dataset, **kwargs)\n hr_df = load_hr()\n age_df, hr_df = clean_data(age_df, hr_df)\n snids = age_df.index.unique().tolist()\n return snids, age_df, hr_df","def get_time_slices(self):\n tot = []\n for clu in self._clusters:\n tot.extend(self._clusters[clu].to_dict()[:])\n #tot.sort()\n return tot","def testbaselinelc(self):\n a_in = os.path.join(self.datadir,\n 'monol_testA_E3-50_lc' + HEN_FILE_EXTENSION)\n out = os.path.join(self.datadir, 'monol_test_baselc')\n command = '{0} -o {1} -p 0.001 --lam 1e5'.format(a_in, out)\n\n hen.lcurve.baseline_main(command.split())\n out_lc = hen.io.load_lcurve(out + '_0' + HEN_FILE_EXTENSION)\n assert hasattr(out_lc, 'base')\n gti_to_test = hen.io.load_events(self.first_event_file).gti\n assert np.allclose(gti_to_test, out_lc.gti)","def test_list_grading_periods_courses(self):\r\n course_id = None # Change me!!\r\n\r\n r = self.client.list_grading_periods_courses(course_id)","def prepare_data():\n #data, label = load_ta_data(), load_ta_target()\n data, label = load_own_data(), load_own_target()\n tra_x, tst_x = split_samples(data)\n tra_y, tst_y = split_samples(label)\n return (tra_x, tst_x, tra_y, tst_y)","def getTrainTimes(t1,testTimes):\n trn=t1.copy(deep=True)\n for i,j in testTimes.iteritems():\n df0=trn[(i<=trn.index)&(trn.index<=j)].index # train starts within test\n df1=trn[(i<=trn)&(trn<=j)].index # train ends within test\n df2=trn[(trn.index<=i)&(j<=trn)].index # train envelops test\n trn=trn.drop(df0.union(df1).union(df2))\n return trn","def test_xblockcompletion_no_data_course(self):\n from lms.djangoapps.courseware.models import StudentModule\n data = {\n 'format':'all'\n }\n response = self.client_instructor.get(reverse('xblockcompletion-data:data'), data)\n self.assertEqual(response.status_code, 200)\n self.assertEqual(json.loads(response._container[0].decode()), {'error': 'Falta parametro course o parametro incorrecto'})","def new_data(self, base: str, first: pd.Timestamp, last: pd.Timestamp):\n ohlcv = self.predictor.ohlcv.get_data(base, first, last)\n fdf = self.predictor.features.get_data(base, first, last)\n tdf = self.predictor.targets.get_data(base, first, last)\n if (tdf is None) or tdf.empty:\n return None\n pred = self.predict_batch(base, fdf)\n pdf = pd.DataFrame(data=pred, index=fdf.index, columns=self.keys())\n pdf = pd.concat([ohlcv.close, tdf.target, pdf], axis=1, join=\"inner\")\n return self.check_timerange(pdf, first, last)","def evaluate_baseline(test_data):\n\n # create mapping xor diff -> biterrors \n error_values = np.array([bin(x).count('1') for x in range(CONST_POINTS)]) \n\n x_raw, x = test_data\n means = Data_generator().constellations[MODULATION][1]\n x_recon = np.argmin(np.abs(x[:, None] - means[None, :]), axis=1)\n\n diff = x_recon^x_raw # bitwise comparison\n bit_errors = np.sum(error_values[diff])\n ber = bit_errors/(NUM_SAMPLES*BITS_PER_SYMBOL)\n return ber","def compute_random_baseline(self, classes):\n\n # based on the class distribution of the data\n sum_benefit = 0\n\n # c is the actual label\n # if the label in y is unseen when training, skip it, don't include it in the error\n for i, c in enumerate(self.y_chunk):\n for j, cprime in enumerate(classes):\n\n # (1) compute the benefit matrix\n benefit_c_cprime = 0\n if cprime == self.fraud_label:\n benefit_c_cprime = self.X_chunk[i][-1] - self.cost if c == self.fraud_label else -self.cost\n\n # (2) get the probability\n probab_ic = 1 / len(classes)\n sum_benefit += probab_ic * benefit_c_cprime\n\n return sum_benefit","def baseline_TVOC(self) -> int:\n return self.get_iaq_baseline()[1]","def baseline_idx(self, axis=None, strict=False, extrapolate=False):\n # Get stress/release pairs\n if strict:\n # Get only stress/release pairs, i.e. only segment pairs, whose\n # release's stop and stress's start index equal an extremum.\n pairs = self.stress_release_pairs(axis=axis, slices=False)\n stresses = pairs['stress']['idx']\n releases = pairs['release']['idx']\n else:\n # Get all stress/release segments, even those without a\n # corresponding extremum.\n stresses = self.sections(axis=axis, cycle='stress', slices=False)\n releases = self.sections(axis=axis, cycle='release', slices=False)\n\n # A baseline point lies exactly beetween a release and a following\n # stress section. Therefore, the baseline point idx equals a stress's\n # start and a release's stop.\n stress_base_idx = stresses[:, 0]\n release_base_idx = releases[:, 1]\n\n # Remove stresses, whose start, and releases, whose stop is equal to\n # an extremum, which means, the excitation as above or below the\n # baseline.\n extrema = self._extrema(axis=axis)\n stress_base_idx = np.setdiff1d(stress_base_idx, extrema,\n assume_unique=True)\n release_base_idx = np.setdiff1d(release_base_idx, extrema,\n assume_unique=True)\n\n base_idx = np.r_[stress_base_idx, release_base_idx]\n if strict or not extrapolate:\n # Take only baseline point indices, that lie exactly between a\n # release and a following stress section, i.e. have two equal\n # entries, one from a release's start and one from a stress's stop.\n # I.e. sort out all indices that did not come from a stress/release\n # pair but instead only a single stress or release segment.\n base_idx.sort()\n base_idx = base_idx[np.r_[base_idx[:-1] == base_idx[1:], False]]\n return np.unique(base_idx)","def subtract_baseline(waveforms, baseline_start, baseline_end):\n baseline_corrected = (\n waveforms\n - np.mean(waveforms[..., baseline_start:baseline_end], axis=-1)[..., None]\n )\n\n return baseline_corrected","def test_find_cycles_no_cycle(self):\n self._build_sample_graph()\n skill_map = SkillMap.load(self.course)\n self.assertEqual(SkillMapMetrics(skill_map).simple_cycles(), [])","def get_raw_x_data(\n params, fold, subject_list,\n):\n X = []\n\n for subject in subject_list:\n rsfmri_data = load_intertva_rsfmri(\n subject, os.path.join(params[\"orig_path\"], \"features_rsfMRI\")\n )\n\n if params[\"modality\"] == \"gyrification\":\n gyr_data = np.load(\n os.path.join(\n params[\"orig_path\"],\n \"features_gyrification\",\n \"{}_eig_vec_{}_onref_{}.npy\".format(\n subject, params[\"template\"], params[\"ref_subject\"]\n ),\n )\n )\n x_sub_data = np.concatenate([gyr_data, rsfmri_data], axis=1)\n elif params[\"modality\"] == \"tfMRI\":\n tfmri_data = load_intertva_tfmri(\n subject, os.path.join(params[\"orig_path\"], \"features_tfMRI\")\n )\n x_sub_data = np.concatenate([tfmri_data, rsfmri_data], axis=1)\n X.append(x_sub_data)\n\n return X\n # interTVA data has already been run on taskFMRI, on frioul","def training_data(loan_data):\n return loan_data[loan_data.status != \"LIVE\"]","def load_hr_data(self, subject_id:str) -> pd.DataFrame:\n hr_fp = os.path.join(self.hr_dir, subject_id+self.hr_file_suffix)\n df_hr = pd.read_csv(hr_fp,sep=\",\",header=None,names=[\"sec\",\"hr\"])\n df_hr = df_hr.sort_values(by=\"sec\")\n df_hr = df_hr.drop_duplicates(subset=\"sec\")\n df_hr = df_hr.reset_index(drop=True)\n return df_hr","def _makebaselines(self):\n nholes = self.ctrs.shape[0]\n blist = []\n for i in range(nholes):\n for j in range(nholes):\n if i < j:\n blist.append((i, j))\n barray = np.array(blist).astype(np.int)\n #blname = []\n bllist = []\n for basepair in blist:\n # blname.append(\"{0:d}_{1:d}\".format(basepair[0],basepair[1]))\n baseline = self.ctrs[basepair[0]] - self.ctrs[basepair[1]]\n bllist.append(baseline)\n return barray, np.array(bllist)","def get_differences(df_future: pd.DataFrame,\n df_baseline: pd.DataFrame) -> pd.DataFrame:\n\n return (\n df_future.set_index(['subject_id', 'site']) - df_baseline.set_index(\n ['subject_id', 'site'])).reset_index().dropna(subset=['value'])","def mean_baseline(d, mode='test'):\n m = d.trainY.mean()\n y = getattr(d, mode + \"Y\")\n preds = np.array([m] * y.shape[0])\n return (get_mse(d, preds, mode), get_mae(d, preds, mode),\n get_mape(d, preds, mode))","def all_baselines():\n for i in range(len(active_ants)):\n ID1 = active_ants[i]\n for j in range(i + 1, len(active_ants[i + 1:])):\n ID2 = active_ants[j]\n print(\"Baseline between antennae \" + str(ID1) + \\\n \" and \" + str(ID2) + \" = \" + str(ant.baseline(ID1, ID2)))","def baseline(self, baseline: List[PredictionsDatapoints]):\n\n self._baseline = baseline","def ensemble_times(self):\n return self['validtime'].values","def get_obj_df():\n obj_df = pd.read_csv('data/object.csv')\n obj_df = obj_df.drop_duplicates()[['course_id', 'module_id', 'category', 'start']] \n obj_df['start'] = pd.to_datetime(obj_df[obj_df['start'] != 'null']['start'])\n return obj_df","def test_get_derived_metric(self):\n pass","def get_ts_data(self) -> qai_helper.QAIChangedct:\n raise NotImplementedError(\"not implemented\")","def data_for_file (self):\n rowdata = np.array([self.Train_Time_min,self.Train_Time_max,self.Train_Time_avg,\n self.Loss_Value_min,self.Loss_Value_max,self.Loss_Value_avg,\n self.Iterations_min,self.Iterations_max,self.Iterations_avg,\n self.precision_avg,self.recall_avg])\n return rowdata\n\n\n \n\n\n #### FUNCTION DEFINTIIONS ####","def test_Y_no_std (self):\n X, Y = self.dm.get_data(std=True, y_std=False)\n expected = [(pd.to_datetime('1/12/2018'), 0.027151911),\n (pd.to_datetime('1/13/2018'), -0.040960432),\n (pd.to_datetime('1/14/2018'), 0.00347081),\n (pd.to_datetime('1/15/2018'), -0.168548025)]\n\n for (idx, e) in expected:\n msg = 'Y value not what expected on {}'.format(cryp.fmt_date(idx))\n actual = Y[idx]\n self.assertAlmostEqual(e, actual, DEC_ACCY, msg)","def getTrainingData(self):\n raise NotImplementedError","def get_faulty_scenario_data():\n return [\n {\n \"population_count\": 100,\n \"county\": \"oxford\",\n \"season\": \"cold_month\",\n \"year\": 2017,\n },\n {\n \"population_count\": 150,\n \"county\": \"oxford\",\n \"season\": \"spring_month\",\n \"year\": 2017,\n },\n {\n \"population_count\": 200,\n \"county\": \"oxford\",\n \"season\": \"hot_month\",\n \"year\": 2017,\n },\n {\n \"population_count\": 210,\n \"county\": \"oxford\",\n \"season\": \"fall_month\",\n \"year\": 2017,\n },\n ]","def get_data(self)->pd.DataFrame:\n pass","def _assess(self):\n # get eruptions\n with open(os.sep.join(getfile(currentframe()).split(os.sep)[:-2]+['data','eruptive_periods.txt']),'r') as fp:\n self.tes = [datetimeify(ln.rstrip()) for ln in fp.readlines()]\n # check if data file exists\n self.exists = os.path.isfile(self.file)\n if not self.exists:\n t0 = datetime(2011,1,1)\n t1 = datetime(2011,1,2)\n self.update(t0,t1)\n # check date of latest data in file\n self.df = pd.read_csv(self.file, index_col=0, parse_dates=[0,], infer_datetime_format=True)\n self.ti = self.df.index[0]\n self.tf = self.df.index[-1]","def baseline(self, baseline=\"median\", normalize=None, ignore_sessions=False):\n if self.sessions is None or ignore_sessions:\n out = self.copy()\n if type(baseline) == str:\n if baseline == \"median\":\n baseline_values = out.median()\n elif baseline == \"mean\":\n baseline_values = out.mean()\n elif baseline == \"begin\":\n baseline_values = out.iloc[0, :]\n else:\n raise ValueError(\n \"%s is not implemented please use {mean, median, Fex}\"\n % baseline\n )\n elif isinstance(baseline, (Series, FexSeries)):\n baseline_values = baseline\n elif isinstance(baseline, (Fex, DataFrame)):\n raise ValueError(\"Must pass in a FexSeries not a FexSeries Instance.\")\n\n if normalize == \"db\":\n out = 10 * np.log10(out - baseline_values) / baseline_values\n if normalize == \"pct\":\n out = 100 * (out - baseline_values) / baseline_values\n else:\n out = out - baseline_values\n else:\n out = self.__class__(sampling_freq=self.sampling_freq)\n for k, v in self.itersessions():\n if type(baseline) == str:\n if baseline == \"median\":\n baseline_values = v.median()\n elif baseline == \"mean\":\n baseline_values = v.mean()\n elif baseline == \"begin\":\n baseline_values = v.iloc[0, :]\n else:\n raise ValueError(\n \"%s is not implemented please use {mean, median, Fex}\"\n % baseline\n )\n elif isinstance(baseline, (Series, FexSeries)):\n baseline_values = baseline\n elif isinstance(baseline, (Fex, DataFrame)):\n raise ValueError(\n \"Must pass in a FexSeries not a FexSeries Instance.\"\n )\n\n if normalize == \"db\":\n out = out.append(\n 10 * np.log10(v - baseline_values) / baseline_values,\n session_id=k,\n )\n if normalize == \"pct\":\n out = out.append(\n 100 * (v - baseline_values) / baseline_values, session_id=k\n )\n else:\n out = out.append(v - baseline_values, session_id=k)\n return out.__finalize__(self)\n # return self.__class__(out, sampling_freq=self.sampling_freq, features=self.features, sessions=self.sessions)","def loadtrainData_undersampling():\n train = []\n fileIn = open(PATH + 'traindata_Subtask4.txt')\n for line in fileIn.readlines():\n lineArr = line.strip().split()\n train.append([float(lineArr[i]) for i in range(len(lineArr))])\n\n pos = []\n neg = []\n for i in train:\n if i[-1] == 1.0:\n pos.append(i)\n else:\n neg.append(i)\n slice1 = random.sample(neg, len(pos))\n data = pos + slice1\n train_x = []\n train_y = []\n y = []\n for line in data:\n train_x.append([float(line[i]) for i in range(len(line) - 1)])\n y.append([int(line[-1])])\n for i in range(len(y)):\n train_y.append(y[i][0])\n return np.mat(train_x), np.mat(train_y).transpose()","def test_incomplete_dataset():\n train = ((\"Lorem ipsum dolor sit amet\", 3, 4.5),\n (\"Sed ut perspiciatis unde\", 4, 5.5))\n t = TabularDataset(train)\n\n assert len(t.val) == 0\n assert len(t.test) == 0","def timeseries_dataframe(self):\n return","def get_raw_data():\n raw_corpus = get_raw_corpus()\n raw_datetimes = get_raw_datetimes()\n raw_data = []\n for i, raw_datetime in enumerate(raw_datetimes):\n raw_data.append([raw_datetime, raw_corpus[i]])\n return raw_data","def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\n total_days=df.shape[0]\n today_invt_dict=invt_dict\n invt_daily_list=[] # invt after today's transaction\n net_wealth_list=[]\n\n for i in range(total_days):\n if i==0:\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\n elif i==total_days-1: # last day\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\n invt_daily_list.append(today_invt_dict)\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\n \n PrintResult(\"Baseline Strategy\", net_wealth_list)\n plt.plot(net_wealth_list)\n plt.title(\"Baseline (1st day buy->hold->last day sell) Strategy\")\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\n plt.show()\n return","def getCurentData(self):\n if not self.labExperiment:\n super().getCurentData()\n else:\n return np.array(self.connection.query('get_actuator_data'))","def test_no_deprecated_datasets_in_table(self):\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n for dataset in self.datasets_v1:\n self.assertNotIn(dataset, table.data)\n for dataset in self.datasets_v2:\n self.assertNotIn(dataset, table.data)","def testbaselinelc_nooutroot(self):\n a_in = os.path.join(self.datadir,\n 'monol_testA_E3-50_lc' + HEN_FILE_EXTENSION)\n command = '{0} -p 0.001 --lam 1e5'.format(a_in)\n\n hen.lcurve.baseline_main(command.split())\n out_lc = hen.io.load_lcurve(\n hen.base.hen_root(a_in) + '_lc_baseline' + HEN_FILE_EXTENSION)\n assert hasattr(out_lc, 'base')\n gti_to_test = hen.io.load_events(self.first_event_file).gti\n assert np.allclose(gti_to_test, out_lc.gti)","def correct_baseline(trace, config=None):\n if config is None:\n config = get_config()\n\n # Integrate twice to get the displacement time series\n disp_data = get_disp(trace, method=config[\"integration\"][\"method\"])\n\n # Fit a sixth order polynomial to displacement time series, requiring\n # that the 1st and 0th order coefficients are zero\n time_values = (\n np.linspace(0, trace.stats.npts - 1, trace.stats.npts) * trace.stats.delta\n )\n poly_cofs = list(curve_fit(_poly_func, time_values, disp_data)[0])\n poly_cofs += [0, 0]\n\n # Construct a polynomial from the coefficients and compute\n # the second derivative\n polynomial = np.poly1d(poly_cofs)\n polynomial_second_derivative = np.polyder(polynomial, 2)\n\n # Subtract the second derivative of the polynomial from the\n # acceleration trace\n trace.data -= polynomial_second_derivative(time_values)\n trace.setParameter(\"baseline\", {\"polynomial_coefs\": poly_cofs})\n\n return trace","def get_data(self):\n data = list(IgnitionRow.objects.all().order_by('-pub_date')[:self.num_ticks].values())\n two_hours = data[::-1]\n pct_flop_data = [[int(elem['pct_flop_{}'.format(key)]) for elem in two_hours] \n \tfor key in self.keys]\n pct_flop_data = [[min(elem, 100) for elem in arr] for arr in pct_flop_data] # Assume a max pot size of 2000 BBs\n return pct_flop_data","def get_chartdata():\n callback = bottle.request.query.get('callback')\n y_axis = bottle.request.query.get('y_axis').strip()\n w_acts = [\"action='%s'\" % act for act in bottle.request.query.get('actions').strip().split(',')]\n w_acts = 'AND (%s)' % ' OR '.join(w_acts) if w_acts else ''\n f_value = 'AVG(latency)' if y_axis.startswith('avg') else 'COUNT(timestamp)'\n atomic = 1 if y_axis in ['aops', 'avgl'] else 0\n\n db_conn = tools.get_db_conn('%s.db' % bottle.request.query.test_run_id)\n sql = 'SELECT test_run_status, timestamp_started, timestamp_completed FROM info LIMIT 1'\n status, started, finished = tools.db_query(db_conn, sql)[1][0]\n progress = int(float(finished) - float(started)) if finished \\\n else int(tools.get_timestamp() - float(started))\n\n sql = 'SELECT substr(timestamp, 0, 11), code, %s FROM recs ' % f_value + \\\n 'WHERE atomic=%s %s GROUP BY code, substr(timestamp, 0, 11) ' % (atomic, w_acts) + \\\n 'ORDER BY id DESC LIMIT 3600' # last 1 hour activity\n\n result = tools.db_query(db_conn, sql)[1] if finished else tools.db_query(db_conn, sql)[1][:-1]\n result = list(reversed(result))\n results = {str(abs(int(item[0]) - int(float(started)))):\n {'failed': 0, 'passed': 0, 'incomplete': 0} for item in result}\n for item in result: # item[0] - timestamp, item[1] - code (None if incomplete), item[2] - value\n timestamp = str(int(item[0]) - int(float(started)))\n value = item[2] or 0\n results[timestamp]['failed'] += value if item[1] and item[1] != 200 else 0\n results[timestamp]['passed'] += value if item[1] == 200 else 0\n results[timestamp]['incomplete'] += value if item[1] == None else 0\n results = [{'timestamp': key, 'failed': value['failed'], 'passed': value['passed'],\n 'incomplete': value['incomplete']} for key, value in results.items()]\n result = {bottle.request.query.slave: results, 'status': status,\n 'started': started, 'finished': finished or '(not finished)', 'progress': progress}\n return '{0}({1})'.format(callback, result)","def _load_training_data(base_dir):\n train_data = pd.read_csv(os.path.join(base_dir, \"train_vale.csv\")).adjclose.values\n return _data_transformation(train_data)","def get_combined_data(self, file_path: str, train_file_name: str,\n test_file_name: str) -> pd.DataFrame:\n train_data=self.load_dataset(file_path,train_file_name)\n train_data=train_data.drop('Survived', 1)\n test_data=self.load_dataset(file_path,test_file_name)\n\n combined_data = train_data.append(test_data)\n combined_data.reset_index(inplace=True)\n combined_data.drop('index', inplace=True, axis=1)\n\n return combined_data","def fetch_data(self) -> pd.DataFrame:\r\n os.chdir(r'\\\\192.168.8.90\\投研部\\Jessica\\test_data')\r\n if self.tic in ['RB.CCRI', 'HC.CCRI', 'I.CCRI', 'J.CCRI', 'JM.CCRI', 'ZC.CCRI']:\r\n f = pd.read_hdf('data.h5', 'snc')\r\n if self.tic in ['CU.CCRI', 'ZN.CCRI', 'AL.CCRI', 'NI.CCRI']:\r\n f = pd.read_hdf('data.h5', 'met')\r\n data = f.loc[f.loc[:, 'sec_code'] == self.tic, :]\r\n # extract I.CCRI data\r\n table = pd.pivot_table(data, index=['date'], columns=['factor_code'], values='factor_value')\r\n table = table.sort_values(by='date')\r\n \r\n return table","def claim_document_baseline():\n param_range = namedtuple('param_range','start, end')\n alpha_settings = param_range(0,1)#,param_range(10,11)\n beta_settings = param_range(0,1)#,param_range(9,10)] #as it finished at beta=0.9\n lambda_settings = param_range(0,11)\n \n claim_document_baseline_LOO(alpha_settings,beta_settings,lambda_settings)","def get_total_data():\n return pd.merge(compute_aggregate_load_data(), compute_aggregate_weather_data(),on=\"Date\")"],"string":"[\n \"def emissions_baseline(self):\\n baseline = DataFrame(columns=[\\\"CO2\\\", \\\"NOx\\\", \\\"PM10\\\", \\\"PM2.5\\\", \\\"SO2\\\"])\\n baseline = baseline.append(year_1(self.plant.emissions()))\\n baseline = baseline.append(year_1(self.plant.fuel_reseller().emissions()))\\n baseline = baseline.append(year_1(self.farmer.emissions_exante))\\n baseline.loc[\\\"Total\\\"] = baseline.sum()\\n baseline.loc[\\\"Total_plant\\\"] = baseline.iloc[0]\\n baseline.loc[\\\"Total_transport\\\"] = baseline.iloc[1]\\n baseline.loc[\\\"Total_field\\\"] = baseline.iloc[2]\\n return baseline\",\n \"def baseline(self) -> List[PredictionsDatapoints]:\\n return self._baseline\",\n \"def organise_baseline_data(self):\\n self.baseline_data = {}\\n for injkey in self.data_sets.keys():\\n data = {}\\n baseline_result = self.data_sets[injkey].pop('full_syst_baseline')\\n datakey = baseline_result.keys()[0]\\n baseline_data = self.systtest_fit_extract(\\n fit_data=baseline_result[datakey],\\n datakey=datakey,\\n labels=self.labels[injkey]['full_syst_baseline'].dict\\n )\\n self.baseline_data[injkey] = baseline_data\",\n \"def baselineFrames(self):\\n frames=[]\\n for tag,T1,T2 in [x for x in self.tags if x[0]=='baseline']:\\n for i,timePoint in enumerate(self.conf['times']):\\n if timePoint>=T1*60 and timePoint<=T2*60:\\n frames.append(i)\\n return frames\\n else:\\n return [0]\",\n \"def baseline(x_data, y_data, stra = \\\"uniform\\\"):\\r\\n x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.2)\\r\\n dummy = DummyClassifier(strategy= stra)\\r\\n dummy.fit(x_train, y_train)\\r\\n y_pred = dummy.predict(x_test)\\r\\n accu = accuracy_score(y_test, y_pred)\\r\\n return accu\",\n \"def __getBaselineList(self):\\n\\n # cumulative baseline selections do not reflect on the msselectedindices()\\n if self._msTool is None:\\n self.__selectMS()\\n\\n \\n # If there are any previous antenna selections, use it\\n if self._arg['antenna'] != '':\\n baselineSelection = {'baseline':self._arg['antenna']}\\n try:\\n self._msTool.msselect(baselineSelection, onlyparse=False)\\n # IMPORTANT: msselectedindices() will always say there are auto-correlation\\n # baselines, even when there aren't. In the MMS case, the SubMS creation will\\n # issue a MSSelectionNullSelection and not be created. \\n baselinelist = self._msTool.msselectedindices()['baselines']\\n except:\\n baselinelist = []\\n else:\\n md = msmdtool()\\n md.open(self._arg['vis'])\\n baselines = md.baselines()\\n md.close()\\n import numpy as np\\n baselinelist = np.vstack(np.where(np.triu(baselines))).T \\n \\n\\n return baselinelist.tolist()\",\n \"def getDataForLoadComparisons(self):\\n\\n\\t\\t# Variables\\n\\t\\tload_data = self.getLoadData() \\n\\t\\tvalues = [] \\n\\t\\tinner_dict = {}\\n\\t\\touter_dict = {}\\n\\t\\tfinal_data = []\\n\\t\\tyesterday = self.helper.getYesterday()\\n\\t\\tkey = self.helper.getYear() + self.helper.getMonth() + self.helper.getDay() + \\\"-loadData\\\"\\n\\t\\tdata = load_data[yesterday[0]][int(yesterday[1])][int(yesterday[2])]\\n\\t\\tdates = (['12:00 AM','1:00 AM','2:00 AM','3:00 AM','4:00 AM','5:00 AM',\\n\\t\\t\\t'6:00 AM','7:00 AM','8:00 AM','9:00 AM','10:00 AM','11:00 AM',\\n\\t\\t\\t'12:00 PM','1:00 PM','2:00 PM','3:00 PM','4:00 PM','5:00 PM',\\n\\t\\t\\t'6:00 PM','7:00 PM','8:00 PM','9:00 PM','10:00 PM','11:00 PM'])\\n\\n\\t\\t# Populating values array\\n\\t\\tfor i in range(0,len(data)):\\n\\t\\t\\tinner_dict['label'] = dates[i]\\n\\t\\t\\tinner_dict['value'] = data[i]\\n\\t\\t\\tvalues.append(inner_dict)\\n\\t\\t\\tinner_dict = {}\\n\\n\\t\\t# Populating the final_data array and returning it\\n\\t\\touter_dict['key'] = key\\n\\t\\touter_dict['values'] = values\\n\\t\\tfinal_data.append(outer_dict)\\n\\n\\t\\treturn final_data\",\n \"def calculate_ddct(self, baseline_time=0):\\n\\n if baseline_time == 0:\\n baseline = self.baseline_data['dct'][0]\\n\\n elif baseline_time == 96:\\n baseline = self.baseline_data['dct'][96]\\n\\n elif baseline_time == 'average':\\n baseline = (self.baseline_data['dct'][0] + self.baseline_data['dct'][96]) / 2\\n\\n control =self.treatment_data.query('treatment == \\\"Control\\\"')['dct']\\n tgf = self.treatment_data.query('treatment == \\\"TGFb\\\"')['dct']\\n control.index = control.index.droplevel(1)\\n tgf.index = tgf.index.droplevel(1)\\n baseline.index = baseline.index.droplevel(1)\\n\\n time = control.columns\\n\\n tgf = pandas.concat([tgf[i]/baseline for i in tgf.columns], axis=1)\\n control = pandas.concat([control[i]/baseline for i in control.columns], axis=1)\\n\\n control.columns = time\\n tgf.columns = time\\n\\n control = pandas.DataFrame(control.stack())\\n tgf = pandas.DataFrame(tgf.stack())\\n control['treatment'] = 'Control'\\n tgf['treatment'] = 'TGFb'\\n df = pandas.concat([control, tgf]).reset_index()\\n df.rename(columns={0: 'ddct'})\\n return df\",\n \"def test_get_derived_metric_history(self):\\n pass\",\n \"def get_iaq_baseline(self) -> List[int]:\\n # name, command, signals, delay\\n return self._run_profile((\\\"iaq_get_baseline\\\", [0x20, 0x15], 2, 0.01))\",\n \"def data_preprocessing(dataset):\\r\\n df = pd.read_csv(dataset)\\r\\n df.head()\\r\\n df.describe()\\r\\n df.isnull().sum()\\r\\n df= df.drop(['instant'], axis=1)\\r\\n df['dteday'] = pd.to_datetime(df['dteday'].apply(str) + ' ' + df['hr'].apply(str) + ':00:00')\\r\\n return df\",\n \"def get_timecourse_data(self, fragment, number):\\n timepoints = self.get_timepoints()\\n timecourse = []\\n for time in timepoints:\\n if self.mdvtc[time].has_data(fragment, number):\\n ratio, stdev, use = self.mdvtc[time].get_data(fragment, number)\\n timecourse.append(ratio)\\n return timecourse\",\n \"def baseline(records, baseline_samples=40):\\n if not len(records):\\n return\\n samples_per_record = len(records[0]['data'])\\n\\n # Array for looking up last baseline seen in channel\\n # We only care about the channels in this set of records; a single .max()\\n # is worth avoiding the hassle of passing n_channels around\\n last_bl_in = np.zeros(records['channel'].max() + 1, dtype=np.int16)\\n\\n for d_i, d in enumerate(records):\\n\\n # Compute the baseline if we're the first record of the pulse,\\n # otherwise take the last baseline we've seen in the channel\\n if d.record_i == 0:\\n bl = last_bl_in[d.channel] = d.data[:baseline_samples].mean()\\n else:\\n bl = last_bl_in[d.channel]\\n\\n # Subtract baseline from all data samples in the record\\n # (any additional zeros should be kept at zero)\\n last = min(samples_per_record,\\n d.pulse_length - d.record_i * samples_per_record)\\n d.data[:last] = int(bl) - d.data[:last]\\n d.baseline = bl\",\n \"def calc_baseline(signal):\\n ssds = np.zeros((3))\\n\\n cur_lp = np.copy(signal)\\n iterations = 0\\n while True:\\n # Decompose 1 level\\n lp, hp = pywt.dwt(cur_lp, \\\"db4\\\")\\n\\n # Shift and calculate the energy of detail/high pass coefficient\\n ssds = np.concatenate(([np.sum(hp ** 2)], ssds[:-1]))\\n\\n # Check if we are in the local minimum of energy function of high-pass signal\\n if ssds[2] > ssds[1] and ssds[1] < ssds[0]:\\n break\\n\\n cur_lp = lp[:]\\n iterations += 1\\n\\n # Reconstruct the baseline from this level low pass signal up to the original length\\n baseline = cur_lp[:]\\n for _ in range(iterations):\\n baseline = pywt.idwt(baseline, np.zeros((len(baseline))), \\\"db4\\\")\\n\\n return baseline[: len(signal)]\",\n \"def baseline(data):\\n weights = weighting(data)\\n return np.inner(weights,data['clicks'])/weights.sum()\",\n \"def graph_baseline(evictiondata, weeks):\\r\\n base_evictions_per_week = {}\\r\\n for index, row in evictiondata.iterrows():\\r\\n if row['week_date'] not in base_evictions_per_week.keys():\\r\\n base_evictions_per_week[row['week_date']] = row['filings_avg']\\r\\n elif row['GEOID'] != 'sealed':\\r\\n base_evictions_per_week[row['week_date']] += row['filings_avg']\\r\\n base_evictions_filed = []\\r\\n for week in weeks:\\r\\n base_evictions_filed.append(base_evictions_per_week[week])\\r\\n\\r\\n plt.figure(figsize=(50, 10))\\r\\n plt.plot(weeks, base_evictions_filed, color='orange')\\r\\n plt.title('Base Evictions filed by the week')\\r\\n plt.xlabel('Date')\\r\\n plt.ylabel('Evictions filed')\\r\\n plt.show()\\r\\n return base_evictions_filed\",\n \"def _load_timecourses(self):\\n # load the timecourses file\\n tcsf = fetch_one_file(self.ica_dir, self._tcs_fname)\\n tcs = niimg.load_img(tcsf).get_data()\\n return tcs\",\n \"def test_no_base_date(self):\\n data = self._data()\\n data.pop('base_date')\\n steps = [{'dateTime': '2012-06-07', 'value': '10'}]\\n TimeSeriesData.objects.create(\\n user=self.user,\\n resource_type=TimeSeriesDataType.objects.get(\\n category=TimeSeriesDataType.activities, resource='steps'),\\n date=steps[0]['dateTime'],\\n value=steps[0]['value']\\n )\\n response = self._mock_utility(response=steps, get_kwargs=data)\\n self._check_response(response, 100, steps)\",\n \"def process_for_baseline(dat):\\n records = []\\n count = 0\\n for record in dat:\\n # Context\\n context = record['context'].replace(\\\"''\\\", '\\\" ').replace(\\\"``\\\", '\\\" ') # Replace non-standard quotation marks\\n context_tokens = text2tokens(context)\\n spans = convert_idx(context, context_tokens) # (token_start_char_idx, token_end_char_idx)\\n \\n # Question\\n ques = record['question'].replace(\\\"''\\\", '\\\" ').replace(\\\"``\\\", '\\\" ') \\n ques_tokens = text2tokens(ques)\\n \\n # Answers\\n y1, y2 = charIdx_to_tokenIdx(spans, record['answers']['text'], record['answers']['answer_start']) \\n\\n res_dict = {\\\"context_tokens\\\": context_tokens,\\n \\\"ques_tokens\\\": ques_tokens,\\n \\\"answer\\\": record['answers']['text'], \\n \\\"y1s\\\": y1, \\n \\\"y2s\\\": y2,\\n \\\"id\\\": count,\\n 'pubId': record['PubID'],\\n \\\"group\\\": record['group']}\\n records.append(res_dict)\\n count += 1 \\n \\n return records\",\n \"def baseline_statistics(self, **_):\\n raise NotImplementedError(\\\"{} doesn't support statistics.\\\".format(__class__.__name__))\",\n \"def all_data(self):\\n return pd.concat([self.historic_data, self.dayahead_data])\",\n \"def _read_baseline(self, path):\\n base_rmsd = dict()\\n fin = open(path,'r')\\n for line in fin:\\n if line == '\\\\s' or line == '' or line == '\\\\n':\\n continue\\n k, v = line.split()\\n base_rmsd[k.strip()] = float(v.strip())\\n return base_rmsd\",\n \"def _load_timecourses(self):\\n # load the timecourses file\\n tcsf = fetch_one_file(self.ica_dir, self._tcs_fname, pat_type='re.match')\\n tcs = niimg.load_img(tcsf).get_data()\\n return tcs\",\n \"def run_baseline_simulation(self):\\n n_days_base = 1 # Only consider 1 day simulation, self.n_days_base\\n sim_time = 24*3600 # one day in seconds\\n \\n print(\\\"Running day-ahead baseline simulation ...\\\") \\n print(\\\"Running baseline right away charging strategy ...\\\")\\n baseline_soc, baseline_std_soc, baseline_power, baseline_cycles, baseline_Tin, baseline_std_Tin, baseline_Tin_max, baseline_Tin_min = self.run_baseline_right_away(n_days_base, sim_time)\\n \\n print(\\\"Exported baseline soc, Temperatures, power and HVAC cycles ...\\\")\\n \\n base_path = dirname(abspath(__file__))\\n path = join(base_path,'data')\\n \\n # Already saved inside the right away function\\n # baseline_soc.to_csv(join(path, r'SOC_baseline.csv'), index = False)\\n # baseline_power.to_csv(join(path, r'power_baseline.csv'), index = False)\\n # baseline_Tin.to_csv(join(path, r'Tin_baseline.csv'), index = False)\\n # baseline_Tin_max.to_csv(join(path, r'Tin_max_baseline.csv'), index = False)\\n # baseline_Tin_min.to_csv(join(path, r'Tin_min_baseline.csv'), index = False)\\n print(\\\"Exported\\\")\",\n \"def baseline(spectra):\\n\\n return spectra - np.mean(spectra, axis=0)\",\n \"def _baseline_value(self):\\n t = self['primary']\\n return np.median(t.data[:int(10e-3/t.dt)])\",\n \"def read_ct_data(train_start, train_count, eval_start, eval_count):\\n data = pd.read_csv('/opt/train.csv')\\n\\n # Dropping the id column\\n data.drop(['ID_code'], axis=1, inplace=True)\\n\\n data = data.values\\n return (data[train_start:train_start + train_count],\\n data[eval_start:eval_start + eval_count])\",\n \"def data(self):\\n if self._data.empty:\\n self._data = super().data\\n\\n max_data_year = self._data[\\\"year\\\"].max()\\n\\n # If the date range of the data doesn't line up with the year filters\\n # for train/test data, we risk getting empty data sets\\n if self.max_year != max_data_year:\\n max_year_diff = pd.to_timedelta(\\n [(YEAR_IN_DAYS * (self.max_year - max_data_year))]\\n * len(self._data),\\n unit=\\\"days\\\",\\n )\\n\\n self._data.loc[:, \\\"date\\\"] = self._data[\\\"date\\\"] + max_year_diff\\n self._data.loc[:, \\\"year\\\"] = self._data[\\\"date\\\"].dt.year\\n self._data.set_index(\\n [\\\"team\\\", \\\"year\\\", \\\"round_number\\\"], drop=False, inplace=True\\n )\\n\\n return self._data\",\n \"def background_subtract_data(data):\\n bgsub_data = data.copy()\\n bax_concs = data.columns.levels[0]\\n lipo_concs = data.columns.levels[1]\\n\\n for bax_conc in data.columns.levels[0]:\\n timecourses = data.xs(bax_conc, axis=1, level='Bax')\\n bg = timecourses[0.]\\n for lipo_conc in lipo_concs:\\n bgsub_tc = timecourses[lipo_conc] - bg\\n bgsub_data[(bax_conc, lipo_conc)] = bgsub_tc\\n\\n return bgsub_data\",\n \"def calc_base_year_data(base_year_vehicles_df):\\n pass\",\n \"def test_get_all_derived_metrics(self):\\n pass\",\n \"def treatments(self):\\n return self.data[self.data['treatment'] != 'Baseline']\",\n \"def persistence_baseline(d, mode='test'):\\n y = getattr(d, mode + \\\"Y\\\")\\n preds = shift(y, 1, cval=0.0)\\n return (get_mse(d, preds, mode), get_mae(d, preds, mode),\\n get_mape(d, preds, mode))\",\n \"def _get_majority_baseline(self) -> np.ndarray:\\n\\n self._majority_label = max(set(self.y_training_set_all_),\\n key=self.y_training_set_all_.count)\\n return np.array([self._majority_label]*len(self.y_training_set_all_))\",\n \"def evalBaseline(self, df = None):\\n \\n if (df is None):\\n self.r_b = self.df.merge(self.df_user[[\\\"user ind\\\", \\\"b_u\\\"]], on = \\\"user ind\\\")\\n self.r_b = self.r_b.merge(self.df_item[[\\\"item ind\\\", \\\"b_i\\\"]], on = \\\"item ind\\\")\\n self.r_b[\\\"baseline\\\"] = self.r_mean + self.r_b[\\\"b_u\\\"] + self.r_b[\\\"b_i\\\"]\\n \\n \\n return self.r_b[[\\\"user id\\\", \\\"item id\\\", \\\"baseline\\\"]]\\n \\n else:\\n df = df.merge(self.df_user, on = \\\"user id\\\").merge(self.df_item, on = \\\"item id\\\")\\n df[\\\"baseline\\\"] = self.r_mean + df[\\\"b_u\\\"] + df[\\\"b_i\\\"]\\n \\n # clip the score to the interval [1, 5]\\n df[\\\"baseline\\\"] = np.minimum(np.maximum(df[\\\"baseline\\\"], 1), 5)\\n \\n return df[[\\\"user id\\\", \\\"item id\\\", \\\"baseline\\\"]]\",\n \"def history(self, t_minus=0):\\n data = self.ohlcv_df[self.ohlcv_df.index <= utc_to_epoch(\\n self.prior_time)]\\n return OHLCVData(data[-t_minus:])\",\n \"def _get_raw_data(self, idx=0):\\n # Get the time step then make a data frame\\n raise NotImplementedError('Code me up!')\\n #data = self._data[???]\\n return data\",\n \"def async_baseline(kwargs):\\n # we can't pickle our objects for remote works so we pickle the raw request\\n # and then load it here.\\n data = baseline_input_schema.load(kwargs).data\\n return baseline(**data)\",\n \"def get_data(t_idx):\\n train_data = []\\n train_label = []\\n valid_data = []\\n valid_label = []\\n test_data = []\\n test_label = []\\n \\n lines = []\\n #f = open('/home/liwenzhe/myworkspace/is13/dataset/closingAdjLog.csv', 'rb')\\n f = open('dataset/closingAdjLog.csv')\\n reader = csv.reader(f)\\n for row in reader:\\n lines.append(row)\\n lines.pop(0)\\n \\n n = len(lines)\\n # use the first 80% for the training data, the next 10% for the validation data\\n # and the last 10% for the test data. \\n # TODO : create folds instead. \\n for i in xrange(n-1, -1, -1):\\n curr_line = lines[i]\\n if i > n * 0.2:\\n # add into training data\\n if t_idx == 0:\\n train_data.append(curr_line[t_idx+1:])\\n else:\\n train_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\\n train_label.append(curr_line[t_idx]) \\n elif i > n * 0.1:\\n # add into validation data\\n if t_idx == 0:\\n valid_data.append(curr_line[t_idx+1:])\\n else: \\n valid_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\\n valid_label.append(curr_line[t_idx]) \\n else:\\n # add into test data\\n if t_idx == 0:\\n test_data.append(curr_line[t_idx+1:])\\n else:\\n test_data.append(curr_line[:t_idx-1] + curr_line[t_idx:])\\n test_label.append(curr_line[t_idx]) \\n \\n return [train_data, train_label, valid_data, valid_label, test_data, test_label]\",\n \"def _calculate(self):\\n source = self.source\\n res = {}\\n l_cols = [[], [], [], []]\\n r_lines = {}\\n dateline=None\\n ###delete the below code when fetch data from database(assume: data in database has been pretreatment)\\n if source[t.ror].min() > -99.0:\\n pass\\n else:\\n source[t.ror] = np.where(\\n source[t.ror] > -99.0, source[t.ror], -99.0)\\n ###\\n for account in self.accounts:\\n source_account = source[source[t.account] == account]\\n source_account = source_account.reset_index(drop=True)\\n dateline=source_account[t.effective_date]\\n ror=source_account[t.ror]/100\\n returns_cum = ROR.ror_cum_ann(source_account, self.annualized)\\n # double_return_cum=round(double_return_cum,2)+1\\n returns_cum = returns_cum + 1\\n growth_amounts = returns_cum * self.starting_value\\n returns_cum, growth_amounts = round(returns_cum - 1, 4), \\\\\\n round(growth_amounts, 2)\\n l_cols[0].append(growth_amounts.iloc[-1, 0])#account growth amount\\n l_cols[1].append(growth_amounts.iloc[-1, 1])#bench growth amount\\n l_cols[2].append(returns_cum.iloc[-1, 0])#account return\\n l_cols[3].append(returns_cum.iloc[-1, 1])#bench return\\n r_lines[account] = [list(returns_cum.iloc[:,0]), list(growth_amounts.iloc[:, 0]),#list(returns_cum.iloc[:, 0])\\n list(growth_amounts.iloc[:, 1])]#account return, account growth amount, bench growth amount\\n res['account_vs_benchmark'] = {'xAxis': self.accounts,\\n 'series': l_cols}\\n res['growth_of_unit'] = {'xAxis': list(dateline),\\n 'series': r_lines}\\n return res\\n # ret_dict = self._ret(accounts, starting_value, source, annualized)\\n # return ret_dict\",\n \"def get_year_uncertainty(bm, num):\\n am_in_use = pd.DataFrame()\\n am_waste = pd.DataFrame()\\n am_total = pd.DataFrame()\\n y_in_use = np.empty(0)\\n y_total = np.empty(0)\\n for j in xrange(num):\\n tmp = get_AM_by_factor()\\n am_in_use[j] = tmp['in-use']\\n am_waste[j] = tmp['waste']\\n am_total[j] = tmp['in-use'] + tmp['waste']\\n bm_rand = bm.iloc[j, :]\\n # For each random couple of timelines - of Biomass and Anthropogenic mass - find the time of intersection and append to array \\n y_in_use = np.append(y_in_use, intersection_time(bm_rand, am_in_use[j]))\\n y_total = np.append(y_total, intersection_time(bm_rand, am_total[j]))\\n return am_in_use, am_waste, am_total, y_in_use, y_total\",\n \"def baseline(*args):\\n XTrain, XTest, yTrain, yTest = args\\n clf = DecisionTreeClassifier(random_state=42)\\n clf.fit(XTrain, yTrain)\\n return clf.score(XTest, yTest), clf.feature_importances_\",\n \"def _getBaselineThresh(self):\\n print('Calculating 10% baseline')\\n self.baseline = obrienBaseline.obrienBaseline(\\n self.d['dos1rate'], timeWidth=5.0, \\n cadence=0.1)\\n self.peak_std = ( (self.d['dos1rate'][self.peakInd]/10 - \\n self.baseline[self.peakInd]/10)/ \\n np.sqrt(self.d['dos1rate'][self.peakInd]/10))\\n return\",\n \"def baseline(dataset: Dataset, conf: Namespace) -> np.ndarray:\\n\\n print(\\\"Calibrating global scores...\\\")\\n # Copy dataset dataframe and set up the score and test columns\\n df = dataset.df.copy()\\n df['test'] = df['fold'] == dataset.fold\\n df['score'] = df[dataset.feature]\\n\\n # Extract score and ground truth of train set\\n score = df[ df['test'] == False ][ 'score' ].to_numpy()\\n ground_truth = df[ df['test'] == False ][ 'same' ].to_numpy(dtype=int)\\n\\n # Set up calibrator on train set\\n calibrator = BetaCalibration(scores=score,\\n ground_truth=ground_truth,\\n score_min=-1,\\n score_max=1,\\n )\\n\\n # Run calibrator on all data\\n return calibrator.predict(df['score'])\",\n \"def getMeasures():\",\n \"def mean_baseline(self):\\n train_mean = np.mean(self.data.loc[self.train_index, self.target_name])\\n rmse = np.sqrt(\\n np.mean(np.square(self.data.loc[self.test_index, self.target_name] - train_mean)))\\n print 'mean baseline RMSE: {}'.format(rmse)\",\n \"def year_absolute_baseline_difference_rule(_m, y):\\r\\n\\r\\n return m.z_b1[y] + m.z_b2[y]\",\n \"def year_absolute_baseline_difference_rule(_m, y):\\r\\n\\r\\n return m.z_b1[y] + m.z_b2[y]\",\n \"def get_perf(self) :\\n self.train()\\n self.df_true = self.df_true[self.length:]\\n self.accuracy , self.recall, self.specificity, self.profit, self.min , self.max = get_accuracy_LSTM(self.df_test, self.df_true,self.model, self.length)\",\n \"def baseline_total_organic_compound(self):\\n return self.indoor_air_quality_baseline[1]\",\n \"def yearly(self):\\r\\n return RecordsYearly(self)\",\n \"def get_data(dataset, **kwargs):\\n age_df = load_age_sample_from_mcmc_chains(dataset, **kwargs)\\n hr_df = load_hr()\\n age_df, hr_df = clean_data(age_df, hr_df)\\n snids = age_df.index.unique().tolist()\\n return snids, age_df, hr_df\",\n \"def get_time_slices(self):\\n tot = []\\n for clu in self._clusters:\\n tot.extend(self._clusters[clu].to_dict()[:])\\n #tot.sort()\\n return tot\",\n \"def testbaselinelc(self):\\n a_in = os.path.join(self.datadir,\\n 'monol_testA_E3-50_lc' + HEN_FILE_EXTENSION)\\n out = os.path.join(self.datadir, 'monol_test_baselc')\\n command = '{0} -o {1} -p 0.001 --lam 1e5'.format(a_in, out)\\n\\n hen.lcurve.baseline_main(command.split())\\n out_lc = hen.io.load_lcurve(out + '_0' + HEN_FILE_EXTENSION)\\n assert hasattr(out_lc, 'base')\\n gti_to_test = hen.io.load_events(self.first_event_file).gti\\n assert np.allclose(gti_to_test, out_lc.gti)\",\n \"def test_list_grading_periods_courses(self):\\r\\n course_id = None # Change me!!\\r\\n\\r\\n r = self.client.list_grading_periods_courses(course_id)\",\n \"def prepare_data():\\n #data, label = load_ta_data(), load_ta_target()\\n data, label = load_own_data(), load_own_target()\\n tra_x, tst_x = split_samples(data)\\n tra_y, tst_y = split_samples(label)\\n return (tra_x, tst_x, tra_y, tst_y)\",\n \"def getTrainTimes(t1,testTimes):\\n trn=t1.copy(deep=True)\\n for i,j in testTimes.iteritems():\\n df0=trn[(i<=trn.index)&(trn.index<=j)].index # train starts within test\\n df1=trn[(i<=trn)&(trn<=j)].index # train ends within test\\n df2=trn[(trn.index<=i)&(j<=trn)].index # train envelops test\\n trn=trn.drop(df0.union(df1).union(df2))\\n return trn\",\n \"def test_xblockcompletion_no_data_course(self):\\n from lms.djangoapps.courseware.models import StudentModule\\n data = {\\n 'format':'all'\\n }\\n response = self.client_instructor.get(reverse('xblockcompletion-data:data'), data)\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(json.loads(response._container[0].decode()), {'error': 'Falta parametro course o parametro incorrecto'})\",\n \"def new_data(self, base: str, first: pd.Timestamp, last: pd.Timestamp):\\n ohlcv = self.predictor.ohlcv.get_data(base, first, last)\\n fdf = self.predictor.features.get_data(base, first, last)\\n tdf = self.predictor.targets.get_data(base, first, last)\\n if (tdf is None) or tdf.empty:\\n return None\\n pred = self.predict_batch(base, fdf)\\n pdf = pd.DataFrame(data=pred, index=fdf.index, columns=self.keys())\\n pdf = pd.concat([ohlcv.close, tdf.target, pdf], axis=1, join=\\\"inner\\\")\\n return self.check_timerange(pdf, first, last)\",\n \"def evaluate_baseline(test_data):\\n\\n # create mapping xor diff -> biterrors \\n error_values = np.array([bin(x).count('1') for x in range(CONST_POINTS)]) \\n\\n x_raw, x = test_data\\n means = Data_generator().constellations[MODULATION][1]\\n x_recon = np.argmin(np.abs(x[:, None] - means[None, :]), axis=1)\\n\\n diff = x_recon^x_raw # bitwise comparison\\n bit_errors = np.sum(error_values[diff])\\n ber = bit_errors/(NUM_SAMPLES*BITS_PER_SYMBOL)\\n return ber\",\n \"def compute_random_baseline(self, classes):\\n\\n # based on the class distribution of the data\\n sum_benefit = 0\\n\\n # c is the actual label\\n # if the label in y is unseen when training, skip it, don't include it in the error\\n for i, c in enumerate(self.y_chunk):\\n for j, cprime in enumerate(classes):\\n\\n # (1) compute the benefit matrix\\n benefit_c_cprime = 0\\n if cprime == self.fraud_label:\\n benefit_c_cprime = self.X_chunk[i][-1] - self.cost if c == self.fraud_label else -self.cost\\n\\n # (2) get the probability\\n probab_ic = 1 / len(classes)\\n sum_benefit += probab_ic * benefit_c_cprime\\n\\n return sum_benefit\",\n \"def baseline_TVOC(self) -> int:\\n return self.get_iaq_baseline()[1]\",\n \"def baseline_idx(self, axis=None, strict=False, extrapolate=False):\\n # Get stress/release pairs\\n if strict:\\n # Get only stress/release pairs, i.e. only segment pairs, whose\\n # release's stop and stress's start index equal an extremum.\\n pairs = self.stress_release_pairs(axis=axis, slices=False)\\n stresses = pairs['stress']['idx']\\n releases = pairs['release']['idx']\\n else:\\n # Get all stress/release segments, even those without a\\n # corresponding extremum.\\n stresses = self.sections(axis=axis, cycle='stress', slices=False)\\n releases = self.sections(axis=axis, cycle='release', slices=False)\\n\\n # A baseline point lies exactly beetween a release and a following\\n # stress section. Therefore, the baseline point idx equals a stress's\\n # start and a release's stop.\\n stress_base_idx = stresses[:, 0]\\n release_base_idx = releases[:, 1]\\n\\n # Remove stresses, whose start, and releases, whose stop is equal to\\n # an extremum, which means, the excitation as above or below the\\n # baseline.\\n extrema = self._extrema(axis=axis)\\n stress_base_idx = np.setdiff1d(stress_base_idx, extrema,\\n assume_unique=True)\\n release_base_idx = np.setdiff1d(release_base_idx, extrema,\\n assume_unique=True)\\n\\n base_idx = np.r_[stress_base_idx, release_base_idx]\\n if strict or not extrapolate:\\n # Take only baseline point indices, that lie exactly between a\\n # release and a following stress section, i.e. have two equal\\n # entries, one from a release's start and one from a stress's stop.\\n # I.e. sort out all indices that did not come from a stress/release\\n # pair but instead only a single stress or release segment.\\n base_idx.sort()\\n base_idx = base_idx[np.r_[base_idx[:-1] == base_idx[1:], False]]\\n return np.unique(base_idx)\",\n \"def subtract_baseline(waveforms, baseline_start, baseline_end):\\n baseline_corrected = (\\n waveforms\\n - np.mean(waveforms[..., baseline_start:baseline_end], axis=-1)[..., None]\\n )\\n\\n return baseline_corrected\",\n \"def test_find_cycles_no_cycle(self):\\n self._build_sample_graph()\\n skill_map = SkillMap.load(self.course)\\n self.assertEqual(SkillMapMetrics(skill_map).simple_cycles(), [])\",\n \"def get_raw_x_data(\\n params, fold, subject_list,\\n):\\n X = []\\n\\n for subject in subject_list:\\n rsfmri_data = load_intertva_rsfmri(\\n subject, os.path.join(params[\\\"orig_path\\\"], \\\"features_rsfMRI\\\")\\n )\\n\\n if params[\\\"modality\\\"] == \\\"gyrification\\\":\\n gyr_data = np.load(\\n os.path.join(\\n params[\\\"orig_path\\\"],\\n \\\"features_gyrification\\\",\\n \\\"{}_eig_vec_{}_onref_{}.npy\\\".format(\\n subject, params[\\\"template\\\"], params[\\\"ref_subject\\\"]\\n ),\\n )\\n )\\n x_sub_data = np.concatenate([gyr_data, rsfmri_data], axis=1)\\n elif params[\\\"modality\\\"] == \\\"tfMRI\\\":\\n tfmri_data = load_intertva_tfmri(\\n subject, os.path.join(params[\\\"orig_path\\\"], \\\"features_tfMRI\\\")\\n )\\n x_sub_data = np.concatenate([tfmri_data, rsfmri_data], axis=1)\\n X.append(x_sub_data)\\n\\n return X\\n # interTVA data has already been run on taskFMRI, on frioul\",\n \"def training_data(loan_data):\\n return loan_data[loan_data.status != \\\"LIVE\\\"]\",\n \"def load_hr_data(self, subject_id:str) -> pd.DataFrame:\\n hr_fp = os.path.join(self.hr_dir, subject_id+self.hr_file_suffix)\\n df_hr = pd.read_csv(hr_fp,sep=\\\",\\\",header=None,names=[\\\"sec\\\",\\\"hr\\\"])\\n df_hr = df_hr.sort_values(by=\\\"sec\\\")\\n df_hr = df_hr.drop_duplicates(subset=\\\"sec\\\")\\n df_hr = df_hr.reset_index(drop=True)\\n return df_hr\",\n \"def _makebaselines(self):\\n nholes = self.ctrs.shape[0]\\n blist = []\\n for i in range(nholes):\\n for j in range(nholes):\\n if i < j:\\n blist.append((i, j))\\n barray = np.array(blist).astype(np.int)\\n #blname = []\\n bllist = []\\n for basepair in blist:\\n # blname.append(\\\"{0:d}_{1:d}\\\".format(basepair[0],basepair[1]))\\n baseline = self.ctrs[basepair[0]] - self.ctrs[basepair[1]]\\n bllist.append(baseline)\\n return barray, np.array(bllist)\",\n \"def get_differences(df_future: pd.DataFrame,\\n df_baseline: pd.DataFrame) -> pd.DataFrame:\\n\\n return (\\n df_future.set_index(['subject_id', 'site']) - df_baseline.set_index(\\n ['subject_id', 'site'])).reset_index().dropna(subset=['value'])\",\n \"def mean_baseline(d, mode='test'):\\n m = d.trainY.mean()\\n y = getattr(d, mode + \\\"Y\\\")\\n preds = np.array([m] * y.shape[0])\\n return (get_mse(d, preds, mode), get_mae(d, preds, mode),\\n get_mape(d, preds, mode))\",\n \"def all_baselines():\\n for i in range(len(active_ants)):\\n ID1 = active_ants[i]\\n for j in range(i + 1, len(active_ants[i + 1:])):\\n ID2 = active_ants[j]\\n print(\\\"Baseline between antennae \\\" + str(ID1) + \\\\\\n \\\" and \\\" + str(ID2) + \\\" = \\\" + str(ant.baseline(ID1, ID2)))\",\n \"def baseline(self, baseline: List[PredictionsDatapoints]):\\n\\n self._baseline = baseline\",\n \"def ensemble_times(self):\\n return self['validtime'].values\",\n \"def get_obj_df():\\n obj_df = pd.read_csv('data/object.csv')\\n obj_df = obj_df.drop_duplicates()[['course_id', 'module_id', 'category', 'start']] \\n obj_df['start'] = pd.to_datetime(obj_df[obj_df['start'] != 'null']['start'])\\n return obj_df\",\n \"def test_get_derived_metric(self):\\n pass\",\n \"def get_ts_data(self) -> qai_helper.QAIChangedct:\\n raise NotImplementedError(\\\"not implemented\\\")\",\n \"def data_for_file (self):\\n rowdata = np.array([self.Train_Time_min,self.Train_Time_max,self.Train_Time_avg,\\n self.Loss_Value_min,self.Loss_Value_max,self.Loss_Value_avg,\\n self.Iterations_min,self.Iterations_max,self.Iterations_avg,\\n self.precision_avg,self.recall_avg])\\n return rowdata\\n\\n\\n \\n\\n\\n #### FUNCTION DEFINTIIONS ####\",\n \"def test_Y_no_std (self):\\n X, Y = self.dm.get_data(std=True, y_std=False)\\n expected = [(pd.to_datetime('1/12/2018'), 0.027151911),\\n (pd.to_datetime('1/13/2018'), -0.040960432),\\n (pd.to_datetime('1/14/2018'), 0.00347081),\\n (pd.to_datetime('1/15/2018'), -0.168548025)]\\n\\n for (idx, e) in expected:\\n msg = 'Y value not what expected on {}'.format(cryp.fmt_date(idx))\\n actual = Y[idx]\\n self.assertAlmostEqual(e, actual, DEC_ACCY, msg)\",\n \"def getTrainingData(self):\\n raise NotImplementedError\",\n \"def get_faulty_scenario_data():\\n return [\\n {\\n \\\"population_count\\\": 100,\\n \\\"county\\\": \\\"oxford\\\",\\n \\\"season\\\": \\\"cold_month\\\",\\n \\\"year\\\": 2017,\\n },\\n {\\n \\\"population_count\\\": 150,\\n \\\"county\\\": \\\"oxford\\\",\\n \\\"season\\\": \\\"spring_month\\\",\\n \\\"year\\\": 2017,\\n },\\n {\\n \\\"population_count\\\": 200,\\n \\\"county\\\": \\\"oxford\\\",\\n \\\"season\\\": \\\"hot_month\\\",\\n \\\"year\\\": 2017,\\n },\\n {\\n \\\"population_count\\\": 210,\\n \\\"county\\\": \\\"oxford\\\",\\n \\\"season\\\": \\\"fall_month\\\",\\n \\\"year\\\": 2017,\\n },\\n ]\",\n \"def get_data(self)->pd.DataFrame:\\n pass\",\n \"def _assess(self):\\n # get eruptions\\n with open(os.sep.join(getfile(currentframe()).split(os.sep)[:-2]+['data','eruptive_periods.txt']),'r') as fp:\\n self.tes = [datetimeify(ln.rstrip()) for ln in fp.readlines()]\\n # check if data file exists\\n self.exists = os.path.isfile(self.file)\\n if not self.exists:\\n t0 = datetime(2011,1,1)\\n t1 = datetime(2011,1,2)\\n self.update(t0,t1)\\n # check date of latest data in file\\n self.df = pd.read_csv(self.file, index_col=0, parse_dates=[0,], infer_datetime_format=True)\\n self.ti = self.df.index[0]\\n self.tf = self.df.index[-1]\",\n \"def baseline(self, baseline=\\\"median\\\", normalize=None, ignore_sessions=False):\\n if self.sessions is None or ignore_sessions:\\n out = self.copy()\\n if type(baseline) == str:\\n if baseline == \\\"median\\\":\\n baseline_values = out.median()\\n elif baseline == \\\"mean\\\":\\n baseline_values = out.mean()\\n elif baseline == \\\"begin\\\":\\n baseline_values = out.iloc[0, :]\\n else:\\n raise ValueError(\\n \\\"%s is not implemented please use {mean, median, Fex}\\\"\\n % baseline\\n )\\n elif isinstance(baseline, (Series, FexSeries)):\\n baseline_values = baseline\\n elif isinstance(baseline, (Fex, DataFrame)):\\n raise ValueError(\\\"Must pass in a FexSeries not a FexSeries Instance.\\\")\\n\\n if normalize == \\\"db\\\":\\n out = 10 * np.log10(out - baseline_values) / baseline_values\\n if normalize == \\\"pct\\\":\\n out = 100 * (out - baseline_values) / baseline_values\\n else:\\n out = out - baseline_values\\n else:\\n out = self.__class__(sampling_freq=self.sampling_freq)\\n for k, v in self.itersessions():\\n if type(baseline) == str:\\n if baseline == \\\"median\\\":\\n baseline_values = v.median()\\n elif baseline == \\\"mean\\\":\\n baseline_values = v.mean()\\n elif baseline == \\\"begin\\\":\\n baseline_values = v.iloc[0, :]\\n else:\\n raise ValueError(\\n \\\"%s is not implemented please use {mean, median, Fex}\\\"\\n % baseline\\n )\\n elif isinstance(baseline, (Series, FexSeries)):\\n baseline_values = baseline\\n elif isinstance(baseline, (Fex, DataFrame)):\\n raise ValueError(\\n \\\"Must pass in a FexSeries not a FexSeries Instance.\\\"\\n )\\n\\n if normalize == \\\"db\\\":\\n out = out.append(\\n 10 * np.log10(v - baseline_values) / baseline_values,\\n session_id=k,\\n )\\n if normalize == \\\"pct\\\":\\n out = out.append(\\n 100 * (v - baseline_values) / baseline_values, session_id=k\\n )\\n else:\\n out = out.append(v - baseline_values, session_id=k)\\n return out.__finalize__(self)\\n # return self.__class__(out, sampling_freq=self.sampling_freq, features=self.features, sessions=self.sessions)\",\n \"def loadtrainData_undersampling():\\n train = []\\n fileIn = open(PATH + 'traindata_Subtask4.txt')\\n for line in fileIn.readlines():\\n lineArr = line.strip().split()\\n train.append([float(lineArr[i]) for i in range(len(lineArr))])\\n\\n pos = []\\n neg = []\\n for i in train:\\n if i[-1] == 1.0:\\n pos.append(i)\\n else:\\n neg.append(i)\\n slice1 = random.sample(neg, len(pos))\\n data = pos + slice1\\n train_x = []\\n train_y = []\\n y = []\\n for line in data:\\n train_x.append([float(line[i]) for i in range(len(line) - 1)])\\n y.append([int(line[-1])])\\n for i in range(len(y)):\\n train_y.append(y[i][0])\\n return np.mat(train_x), np.mat(train_y).transpose()\",\n \"def test_incomplete_dataset():\\n train = ((\\\"Lorem ipsum dolor sit amet\\\", 3, 4.5),\\n (\\\"Sed ut perspiciatis unde\\\", 4, 5.5))\\n t = TabularDataset(train)\\n\\n assert len(t.val) == 0\\n assert len(t.test) == 0\",\n \"def timeseries_dataframe(self):\\n return\",\n \"def get_raw_data():\\n raw_corpus = get_raw_corpus()\\n raw_datetimes = get_raw_datetimes()\\n raw_data = []\\n for i, raw_datetime in enumerate(raw_datetimes):\\n raw_data.append([raw_datetime, raw_corpus[i]])\\n return raw_data\",\n \"def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\\n total_days=df.shape[0]\\n today_invt_dict=invt_dict\\n invt_daily_list=[] # invt after today's transaction\\n net_wealth_list=[]\\n\\n for i in range(total_days):\\n if i==0:\\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\\n elif i==total_days-1: # last day\\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\\n invt_daily_list.append(today_invt_dict)\\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\\n \\n PrintResult(\\\"Baseline Strategy\\\", net_wealth_list)\\n plt.plot(net_wealth_list)\\n plt.title(\\\"Baseline (1st day buy->hold->last day sell) Strategy\\\")\\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\\n plt.show()\\n return\",\n \"def getCurentData(self):\\n if not self.labExperiment:\\n super().getCurentData()\\n else:\\n return np.array(self.connection.query('get_actuator_data'))\",\n \"def test_no_deprecated_datasets_in_table(self):\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n for dataset in self.datasets_v1:\\n self.assertNotIn(dataset, table.data)\\n for dataset in self.datasets_v2:\\n self.assertNotIn(dataset, table.data)\",\n \"def testbaselinelc_nooutroot(self):\\n a_in = os.path.join(self.datadir,\\n 'monol_testA_E3-50_lc' + HEN_FILE_EXTENSION)\\n command = '{0} -p 0.001 --lam 1e5'.format(a_in)\\n\\n hen.lcurve.baseline_main(command.split())\\n out_lc = hen.io.load_lcurve(\\n hen.base.hen_root(a_in) + '_lc_baseline' + HEN_FILE_EXTENSION)\\n assert hasattr(out_lc, 'base')\\n gti_to_test = hen.io.load_events(self.first_event_file).gti\\n assert np.allclose(gti_to_test, out_lc.gti)\",\n \"def correct_baseline(trace, config=None):\\n if config is None:\\n config = get_config()\\n\\n # Integrate twice to get the displacement time series\\n disp_data = get_disp(trace, method=config[\\\"integration\\\"][\\\"method\\\"])\\n\\n # Fit a sixth order polynomial to displacement time series, requiring\\n # that the 1st and 0th order coefficients are zero\\n time_values = (\\n np.linspace(0, trace.stats.npts - 1, trace.stats.npts) * trace.stats.delta\\n )\\n poly_cofs = list(curve_fit(_poly_func, time_values, disp_data)[0])\\n poly_cofs += [0, 0]\\n\\n # Construct a polynomial from the coefficients and compute\\n # the second derivative\\n polynomial = np.poly1d(poly_cofs)\\n polynomial_second_derivative = np.polyder(polynomial, 2)\\n\\n # Subtract the second derivative of the polynomial from the\\n # acceleration trace\\n trace.data -= polynomial_second_derivative(time_values)\\n trace.setParameter(\\\"baseline\\\", {\\\"polynomial_coefs\\\": poly_cofs})\\n\\n return trace\",\n \"def get_data(self):\\n data = list(IgnitionRow.objects.all().order_by('-pub_date')[:self.num_ticks].values())\\n two_hours = data[::-1]\\n pct_flop_data = [[int(elem['pct_flop_{}'.format(key)]) for elem in two_hours] \\n \\tfor key in self.keys]\\n pct_flop_data = [[min(elem, 100) for elem in arr] for arr in pct_flop_data] # Assume a max pot size of 2000 BBs\\n return pct_flop_data\",\n \"def get_chartdata():\\n callback = bottle.request.query.get('callback')\\n y_axis = bottle.request.query.get('y_axis').strip()\\n w_acts = [\\\"action='%s'\\\" % act for act in bottle.request.query.get('actions').strip().split(',')]\\n w_acts = 'AND (%s)' % ' OR '.join(w_acts) if w_acts else ''\\n f_value = 'AVG(latency)' if y_axis.startswith('avg') else 'COUNT(timestamp)'\\n atomic = 1 if y_axis in ['aops', 'avgl'] else 0\\n\\n db_conn = tools.get_db_conn('%s.db' % bottle.request.query.test_run_id)\\n sql = 'SELECT test_run_status, timestamp_started, timestamp_completed FROM info LIMIT 1'\\n status, started, finished = tools.db_query(db_conn, sql)[1][0]\\n progress = int(float(finished) - float(started)) if finished \\\\\\n else int(tools.get_timestamp() - float(started))\\n\\n sql = 'SELECT substr(timestamp, 0, 11), code, %s FROM recs ' % f_value + \\\\\\n 'WHERE atomic=%s %s GROUP BY code, substr(timestamp, 0, 11) ' % (atomic, w_acts) + \\\\\\n 'ORDER BY id DESC LIMIT 3600' # last 1 hour activity\\n\\n result = tools.db_query(db_conn, sql)[1] if finished else tools.db_query(db_conn, sql)[1][:-1]\\n result = list(reversed(result))\\n results = {str(abs(int(item[0]) - int(float(started)))):\\n {'failed': 0, 'passed': 0, 'incomplete': 0} for item in result}\\n for item in result: # item[0] - timestamp, item[1] - code (None if incomplete), item[2] - value\\n timestamp = str(int(item[0]) - int(float(started)))\\n value = item[2] or 0\\n results[timestamp]['failed'] += value if item[1] and item[1] != 200 else 0\\n results[timestamp]['passed'] += value if item[1] == 200 else 0\\n results[timestamp]['incomplete'] += value if item[1] == None else 0\\n results = [{'timestamp': key, 'failed': value['failed'], 'passed': value['passed'],\\n 'incomplete': value['incomplete']} for key, value in results.items()]\\n result = {bottle.request.query.slave: results, 'status': status,\\n 'started': started, 'finished': finished or '(not finished)', 'progress': progress}\\n return '{0}({1})'.format(callback, result)\",\n \"def _load_training_data(base_dir):\\n train_data = pd.read_csv(os.path.join(base_dir, \\\"train_vale.csv\\\")).adjclose.values\\n return _data_transformation(train_data)\",\n \"def get_combined_data(self, file_path: str, train_file_name: str,\\n test_file_name: str) -> pd.DataFrame:\\n train_data=self.load_dataset(file_path,train_file_name)\\n train_data=train_data.drop('Survived', 1)\\n test_data=self.load_dataset(file_path,test_file_name)\\n\\n combined_data = train_data.append(test_data)\\n combined_data.reset_index(inplace=True)\\n combined_data.drop('index', inplace=True, axis=1)\\n\\n return combined_data\",\n \"def fetch_data(self) -> pd.DataFrame:\\r\\n os.chdir(r'\\\\\\\\192.168.8.90\\\\投研部\\\\Jessica\\\\test_data')\\r\\n if self.tic in ['RB.CCRI', 'HC.CCRI', 'I.CCRI', 'J.CCRI', 'JM.CCRI', 'ZC.CCRI']:\\r\\n f = pd.read_hdf('data.h5', 'snc')\\r\\n if self.tic in ['CU.CCRI', 'ZN.CCRI', 'AL.CCRI', 'NI.CCRI']:\\r\\n f = pd.read_hdf('data.h5', 'met')\\r\\n data = f.loc[f.loc[:, 'sec_code'] == self.tic, :]\\r\\n # extract I.CCRI data\\r\\n table = pd.pivot_table(data, index=['date'], columns=['factor_code'], values='factor_value')\\r\\n table = table.sort_values(by='date')\\r\\n \\r\\n return table\",\n \"def claim_document_baseline():\\n param_range = namedtuple('param_range','start, end')\\n alpha_settings = param_range(0,1)#,param_range(10,11)\\n beta_settings = param_range(0,1)#,param_range(9,10)] #as it finished at beta=0.9\\n lambda_settings = param_range(0,11)\\n \\n claim_document_baseline_LOO(alpha_settings,beta_settings,lambda_settings)\",\n \"def get_total_data():\\n return pd.merge(compute_aggregate_load_data(), compute_aggregate_weather_data(),on=\\\"Date\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.661995","0.5938596","0.5920818","0.5673383","0.56499016","0.5554714","0.5551037","0.5503436","0.5422899","0.5406511","0.53813374","0.53646106","0.5344754","0.53437316","0.533326","0.5273145","0.52495307","0.5244175","0.5234559","0.5222947","0.5214892","0.5192904","0.51905257","0.51727","0.5168285","0.5108798","0.5105418","0.51014227","0.5100567","0.50957274","0.5078983","0.50738806","0.5069058","0.5043269","0.4990953","0.4989636","0.49851465","0.49692082","0.4967623","0.49613324","0.49527818","0.4946223","0.49433893","0.49342704","0.49311674","0.49287096","0.49163383","0.49163383","0.49047464","0.4895662","0.4893982","0.48920584","0.48802283","0.48741218","0.48665318","0.48633233","0.4862038","0.48619214","0.48613217","0.48527175","0.48373663","0.4836088","0.4831064","0.48290154","0.48187795","0.48171175","0.481523","0.4784418","0.4783294","0.47787374","0.47773606","0.47704738","0.47704294","0.47671956","0.4743132","0.47411254","0.47360906","0.47297165","0.4729711","0.47190934","0.4715818","0.47104922","0.4709129","0.47074682","0.470247","0.47024053","0.46988863","0.46945113","0.46909064","0.46823007","0.4679789","0.46787006","0.46734187","0.4673358","0.46731472","0.46691042","0.466675","0.4661799","0.46572465","0.46564296"],"string":"[\n \"0.661995\",\n \"0.5938596\",\n \"0.5920818\",\n \"0.5673383\",\n \"0.56499016\",\n \"0.5554714\",\n \"0.5551037\",\n \"0.5503436\",\n \"0.5422899\",\n \"0.5406511\",\n \"0.53813374\",\n \"0.53646106\",\n \"0.5344754\",\n \"0.53437316\",\n \"0.533326\",\n \"0.5273145\",\n \"0.52495307\",\n \"0.5244175\",\n \"0.5234559\",\n \"0.5222947\",\n \"0.5214892\",\n \"0.5192904\",\n \"0.51905257\",\n \"0.51727\",\n \"0.5168285\",\n \"0.5108798\",\n \"0.5105418\",\n \"0.51014227\",\n \"0.5100567\",\n \"0.50957274\",\n \"0.5078983\",\n \"0.50738806\",\n \"0.5069058\",\n \"0.5043269\",\n \"0.4990953\",\n \"0.4989636\",\n \"0.49851465\",\n \"0.49692082\",\n \"0.4967623\",\n \"0.49613324\",\n \"0.49527818\",\n \"0.4946223\",\n \"0.49433893\",\n \"0.49342704\",\n \"0.49311674\",\n \"0.49287096\",\n \"0.49163383\",\n \"0.49163383\",\n \"0.49047464\",\n \"0.4895662\",\n \"0.4893982\",\n \"0.48920584\",\n \"0.48802283\",\n \"0.48741218\",\n \"0.48665318\",\n \"0.48633233\",\n \"0.4862038\",\n \"0.48619214\",\n \"0.48613217\",\n \"0.48527175\",\n \"0.48373663\",\n \"0.4836088\",\n \"0.4831064\",\n \"0.48290154\",\n \"0.48187795\",\n \"0.48171175\",\n \"0.481523\",\n \"0.4784418\",\n \"0.4783294\",\n \"0.47787374\",\n \"0.47773606\",\n \"0.47704738\",\n \"0.47704294\",\n \"0.47671956\",\n \"0.4743132\",\n \"0.47411254\",\n \"0.47360906\",\n \"0.47297165\",\n \"0.4729711\",\n \"0.47190934\",\n \"0.4715818\",\n \"0.47104922\",\n \"0.4709129\",\n \"0.47074682\",\n \"0.470247\",\n \"0.47024053\",\n \"0.46988863\",\n \"0.46945113\",\n \"0.46909064\",\n \"0.46823007\",\n \"0.4679789\",\n \"0.46787006\",\n \"0.46734187\",\n \"0.4673358\",\n \"0.46731472\",\n \"0.46691042\",\n \"0.466675\",\n \"0.4661799\",\n \"0.46572465\",\n \"0.46564296\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61777115"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":12890,"cells":{"query":{"kind":"string","value":"Get treatment time courses without baseline data"},"document":{"kind":"string","value":"def treatments(self):\n return self.data[self.data['treatment'] != 'Baseline']"},"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 _load_timecourses(self):\n # load the timecourses file\n tcsf = fetch_one_file(self.ica_dir, self._tcs_fname)\n tcs = niimg.load_img(tcsf).get_data()\n return tcs","def _load_timecourses(self):\n # load the timecourses file\n tcsf = fetch_one_file(self.ica_dir, self._tcs_fname, pat_type='re.match')\n tcs = niimg.load_img(tcsf).get_data()\n return tcs","def get_timecourse_data(self, fragment, number):\n timepoints = self.get_timepoints()\n timecourse = []\n for time in timepoints:\n if self.mdvtc[time].has_data(fragment, number):\n ratio, stdev, use = self.mdvtc[time].get_data(fragment, number)\n timecourse.append(ratio)\n return timecourse","def test_list_grading_periods_courses(self):\r\n course_id = None # Change me!!\r\n\r\n r = self.client.list_grading_periods_courses(course_id)","def get_courses(std):\n return std[2]","def get_courses(self):\r\n\r\n return self.def_ms.get_courses()","def extract_courses():\n if settings.XPRO_COURSES_API_URL:\n return requests.get(settings.XPRO_COURSES_API_URL, timeout=20).json()\n return []","def build_course(self):\n courses = []\n aprovacao_d = {}\n # semestral\n for rate_it in self.__semestral_rate:\n # pega uma lista no qual o primeiro elemento é a taxa, o segundo\n # e o terceiro são quantidades\n rate_data = self.analysis[\"semestral_rate\"][rate_it.name]\n for i in rate_data[0].index:\n if i[0] not in aprovacao_d:\n aprovacao_d[i[0]] = {}\n\n periodo = str(i[1]) + \"/\" + str(i[2])\n aprovacao_d[i[0]][periodo] = [\n float(rate_data[0][i]),\n int(rate_data[1][i]),\n int(rate_data[2][i]),]\n\n note = self.analysis[\"general_note_statistic\"]\n note_last_year = self.analysis[\"last_year_statistic\"]\n for course in self.analysis[\"courses\"].index:\n course_dict = {}\n course_dict[\"disciplina_codigo\"] = course\n course_dict[\"disciplina_nome\"] = self.analysis[\"courses\"][course]\n \n # If the course code is related to more than one name,\n # concatenate these names into an unique string\n if type(course_dict[\"disciplina_nome\"]) != str:\n new_course_name = \" | \".join(list(course_dict[\"disciplina_nome\"]))\n course_dict[\"disciplina_nome\"] = new_course_name\n # quantidade de matriculas\n count = self.analysis[\"general_count_submission\"][course]\n course_dict[\"qtd_alunos\"] = count\n # notas\n course_dict[\"qtd_cursada_aprov\"] = self.analysis[\"coursed_ratio\"][course]\n course_dict[\"nota\"] = [note[0][course], note[1][course]]\n course_dict[\"nota_ultimo_ano\"] = [\n note_last_year[0][course],\n note_last_year[1][course]\n ]\n # taxas\n for rate_it in self.__rates:\n rate_data = self.analysis[\"general_rates\"][rate_it.name]\n course_dict[rate_it.name] = float(rate_data[0][course])\n course_str = rate_it.name.replace(\"taxa\", \"qtd\")\n # count_sel define qual quantidade vai para o json, a especifica\n # ou geral\n course_dict[course_str] = int(\n rate_data[rate_it.count_sel][course])\n # rate_calc = self.analysis[\"general_rates\"][rate_it.name][0]\n\n # taxas do ultimo anos\n course_dict[\"taxa_reprovacao_ultimo_absoluto\"] = self.analysis[\"last_year_taxa_reprovacao_absoluta\"][course]\n course_dict[\"taxa_reprovacao_ultimo_frequencia\"] = self.analysis[\"last_year_taxa_reprovacao_frequencia\"][course]\n\n course_dict[\"grafico_qtd_cursada_aprov\"] = self.analysis[\"coursed_count\"][course]\n course_dict[\"aprovacao_semestral\"] = aprovacao_d[course]\n courses.append(course_dict)\n return courses","def upcoming_courses(aud):\n \n courses = [c for c in aud.all_courses() if c.grade == u\"*\"]\n return [c.number.replace(\"-\", \"\") for c in courses]","def calculate_ddct(self, baseline_time=0):\n\n if baseline_time == 0:\n baseline = self.baseline_data['dct'][0]\n\n elif baseline_time == 96:\n baseline = self.baseline_data['dct'][96]\n\n elif baseline_time == 'average':\n baseline = (self.baseline_data['dct'][0] + self.baseline_data['dct'][96]) / 2\n\n control =self.treatment_data.query('treatment == \"Control\"')['dct']\n tgf = self.treatment_data.query('treatment == \"TGFb\"')['dct']\n control.index = control.index.droplevel(1)\n tgf.index = tgf.index.droplevel(1)\n baseline.index = baseline.index.droplevel(1)\n\n time = control.columns\n\n tgf = pandas.concat([tgf[i]/baseline for i in tgf.columns], axis=1)\n control = pandas.concat([control[i]/baseline for i in control.columns], axis=1)\n\n control.columns = time\n tgf.columns = time\n\n control = pandas.DataFrame(control.stack())\n tgf = pandas.DataFrame(tgf.stack())\n control['treatment'] = 'Control'\n tgf['treatment'] = 'TGFb'\n df = pandas.concat([control, tgf]).reset_index()\n df.rename(columns={0: 'ddct'})\n return df","def get_course(data):\n\n return {item['course'] for item in data}","def ensemble_times(self):\n return self['validtime'].values","def test_find_cycles_no_cycle(self):\n self._build_sample_graph()\n skill_map = SkillMap.load(self.course)\n self.assertEqual(SkillMapMetrics(skill_map).simple_cycles(), [])","def get_courses(self):\n if not self.is_course_based_activity():\n raise IllegalState()\n else:\n raise Unimplemented()","def get_courses(self, depth=0):\r\n return self.courses.values()","def get_time_slices(self):\n tot = []\n for clu in self._clusters:\n tot.extend(self._clusters[clu].to_dict()[:])\n #tot.sort()\n return tot","def prepare_courses_for_radio():\n\n three_closest_courses = get_four_future_courses()\n radio_courses = []\n\n for course in three_closest_courses:\n radio_courses.append(\n (int(course.id), str(reformat_date(course.startDate) + ' r.'))\n )\n return radio_courses","def assembly_courses(wall):\n courses = []\n vertices = set(wall.nodes())\n base = set(wall.nodes_where({'is_support': True}))\n\n if base:\n courses.append(list(base))\n\n seen = set()\n seen.update(base)\n\n vertices -= base\n\n while vertices:\n nbrs = set(nbr for key in courses[-1] for nbr in wall.neighbors(key))\n course = list(nbrs - seen)\n courses.append(course)\n seen.update(nbrs)\n vertices -= nbrs\n\n return courses","def get_courses(self, *args):\n courses = []\n user = self.context['user']\n modules = user.profile.purchased_modules.all()\n for module in modules:\n course_id = self.course_in_courses(module.course.mnemo, courses)\n if course_id:\n courses[course_id[0]]['modules'].append({'mnemo': module.mnemo})\n else:\n courses.append({\n 'mnemo': module.course.mnemo,\n 'modules': [{'mnemo': module.mnemo}]\n })\n return courses","def get_courses_info(url, headers):\n dash = get_page_contents(url, headers)\n soup = BeautifulSoup(dash)\n courses_soup = soup.find_all('article', 'course')\n courses = []\n for course_soup in courses_soup:\n course_id = None\n course_name = course_soup.h3.text.strip()\n course_url = None\n course_state = 'Not yet'\n try:\n # started courses include the course link in the href attribute\n course_url = BASE_URL + course_soup.a['href']\n if course_url.endswith('info') or course_url.endswith('info/'):\n course_state = 'Started'\n # The id of a course in edX is composed by the path\n # {organization}/{course_number}/{course_run]\n course_id = course_soup.a['href'][9:-5]\n except KeyError:\n pass\n courses.append(Course(id=course_id,\n name=course_name,\n url=course_url,\n state=course_state))\n return courses","def get_errored_courses(self):\r\n return {}","def critical_periods(t, unit='yr'):\n Nsamp = len(t)\n T = duration(t, unit)\n f_nyquist_eq = 0.5/(T/Nsamp)\n f_nyquist_med = median_nyquist(t, unit)\n return { 'duration' : T, \n 'nyquist_eq' : 1.0/f_nyquist_eq,\n 'nyquist_med' : 1.0/f_nyquist_med }","def get_courses(self):\n\n self.search([]).unlink()\n token = self.env['odoo.moodle'].search([('create_uid', '=', self.env.user.id)]).token\n domain = \"http://localhost:8888\"\n webservice_url = \"/webservice/rest/server.php?\"\n parameters = {\n \"wstoken\":token,\n 'wsfunction': 'core_course_get_courses',\n 'moodlewsrestformat': 'json'\n }\n request = requests.get(url=domain+webservice_url, params=parameters)\n request = request.json()\n print(request)\n\n for req in request:\n try:\n if req['id']==1:\n pass\n else:\n self.create({\n 'course_id': req['id'], \n 'category':req['categoryid'],\n 'fullname':req['fullname'], \n 'shortname':req['shortname'],\n 'summary': req['summary']\n }\n )\n except Exception:\n print('Course not created')","def test_only_students_courses(self):\n user = self.make_user()\n enrollment = EnrollmentFactory(grade_level__school_year__school=user.school)\n course = CourseFactory(grade_levels=[enrollment.grade_level])\n grade = GradeFactory(\n score=50,\n student=enrollment.student,\n graded_work__course_task__course=course,\n )\n grade_2 = GradeFactory(\n score=100,\n student=enrollment.student,\n graded_work__course_task__course=course,\n )\n GradeFactory(\n graded_work__course_task__course__grade_levels=[enrollment.grade_level]\n )\n\n with self.login(user):\n self.get_check_200(\"reports:progress\", pk=enrollment.id)\n\n assert self.get_context(\"courses\") == [\n {\n \"course\": grade.graded_work.course_task.course,\n \"grades\": [grade, grade_2],\n \"course_average\": 75,\n }\n ]","def get_dummy_course(start):\r\n\r\n system = DummyImportSystem(load_error_modules=True)\r\n\r\n def to_attrb(n, v):\r\n return '' if v is None else '{0}=\"{1}\"'.format(n, v).lower()\r\n\r\n start_xml = '''\r\n <course org=\"{org}\" course=\"{course}\"\r\n graceperiod=\"1 day\" url_name=\"test\"\r\n start=\"{start}\"\r\n >\r\n <chapter url=\"hi\" url_name=\"ch\" display_name=\"CH\">\r\n <randomize url_name=\"my_randomize\">\r\n <html url_name=\"a\" display_name=\"A\">Two houses, ...</html>\r\n <html url_name=\"b\" display_name=\"B\">Three houses, ...</html>\r\n </randomize>\r\n </chapter>\r\n </course>\r\n '''.format(org=ORG, course=COURSE, start=start)\r\n\r\n return system.process_xml(start_xml)","def course_options(self):\n return {\n 'start': datetime.now() - timedelta(days=1)\n }","def emissions_baseline(self):\n baseline = DataFrame(columns=[\"CO2\", \"NOx\", \"PM10\", \"PM2.5\", \"SO2\"])\n baseline = baseline.append(year_1(self.plant.emissions()))\n baseline = baseline.append(year_1(self.plant.fuel_reseller().emissions()))\n baseline = baseline.append(year_1(self.farmer.emissions_exante))\n baseline.loc[\"Total\"] = baseline.sum()\n baseline.loc[\"Total_plant\"] = baseline.iloc[0]\n baseline.loc[\"Total_transport\"] = baseline.iloc[1]\n baseline.loc[\"Total_field\"] = baseline.iloc[2]\n return baseline","def get_product_courses(product):\n if product.content_type.model == CONTENT_TYPE_MODEL_COURSERUN:\n return [product.content_object.course]\n elif product.content_type.model == CONTENT_TYPE_MODEL_COURSE:\n return [product.content_object]\n elif product.content_type.model == CONTENT_TYPE_MODEL_PROGRAM:\n return list(\n product.content_object.courses.all().order_by(\"position_in_program\")\n )","def calc_total_course_duration(timestamps):\n dt_conversion = [datetime.strptime(ts, '%M:%S') for ts in timestamps]\n baseline = datetime(1900, 1, 1, 0, 0, 0)\n for course_dt in dt_conversion:\n baseline = baseline + timedelta(minutes=course_dt.minute, seconds=course_dt.second) \n\n return baseline.strftime('%-H:%M:%S')","def test_delete_grading_period_courses(self):\r\n course_id = None # Change me!!\r\n id = None # Change me!!\r\n\r\n r = self.client.delete_grading_period_courses(id, course_id)","def phases(self,dataset):\n start = '1984-1-1'\n if dataset == \"ISCCP_raw\":\n stop = '2007-12-31'\n else:\n stop = '2009-12-31'\n X = getattr(self,dataset)(time=(start,stop))\n R,P = sc.fast_annual_cycle(X)\n return MV.masked_where(np.isnan(P),P)","def _course_from_query_response(self, term, response):\n units_low, units_hi = float(response['UNITS_LOW']), float(response['UNITS_HIGH'])\n if units_low > units_hi:\n # Yes, this is an actual response case...\n # Occurs when a course has a constant # of units.\n # I think units_hi should equal units_low when actual units is constant.\n units_hi = units_low\n\n instructor_name = instructor_email = None\n try:\n instructor_meta = next(instr for instr in response['INSTRUCTORS'] if instr['PRIMARY_IND'] == 'Y')\n instructor_name = '{} {}'.format(instructor_meta['FIRST_NAME'], instructor_meta['LAST_NAME'])\n instructor_name = instructor_name.strip()\n instructor_email = instructor_meta['EMAIL']\n except StopIteration:\n # No instructor specified\n pass\n\n ge_areas = list()\n try:\n area_codes = filter(None, response['GE3CREDIT'].split(','))\n ge_areas = [GE_AREA_NAMES_BY_SB_CODE[area_code] for area_code in area_codes]\n except KeyError as e:\n logging.exception('Unrecognized GE code')\n\n meetings = list()\n for meeting in response['COURSEMEETINGDATA']:\n days = meeting['WEEKDAYS'].replace(',', '')\n times = None\n try:\n begin_hour, begin_minutes = meeting['BEGIN_TIME'][:2], meeting['BEGIN_TIME'][2:]\n end_hour, end_minutes = meeting['END_TIME'][:2], meeting['END_TIME'][2:]\n begin = timedelta(hours=int(begin_hour), minutes=int(begin_minutes))\n end = timedelta(hours=int(end_hour), minutes=int(end_minutes))\n times = (begin, end)\n except TypeError:\n # times are None, indicating TBA\n pass\n\n location = meeting['BLDG_DESC']\n if meeting['ROOM']:\n location += ' ' + meeting['ROOM']\n\n meeting = {\n 'days': days,\n 'times': times,\n 'location': location,\n 'type': meeting['MEET_TYPE_DESC_SHORT']\n }\n meetings.append(meeting)\n\n final_exam = None\n try:\n final_exam = datetime.strptime(response['FINALEXAMSTARTDATE'], '%B, %d %Y %H:%M:%S')\n except TypeError:\n # No final exam\n pass\n\n drop_time = response['ALLOWEDDROPDESC']\n drop_days_match = re.match(r'^([0-9]+)', drop_time)\n if drop_days_match:\n drop_time = int(drop_days_match.group(1))\n if response['DESCRIPTION']:\n response['DESCRIPTION'] = response['DESCRIPTION'].replace('\\n', ' ').replace('\\r', '').strip()\n response['TITLE'] = response['TITLE'].strip()\n\n return Course(\n term=term,\n crn=response['PASSEDCRN'],\n subject_code=response['SUBJECT_CODE'],\n name='{} {}'.format(response['SUBJECT_CODE'], response['COURSE_NUMBER']),\n number=response['COURSE_NUMBER'],\n section=response['SEC'],\n title=response['TITLE'].strip(),\n description=response['DESCRIPTION'],\n instructor_consent_required=bool(int(response['CONSENTOFINSRUCTORREQUIRED'])),\n units=(units_low, units_hi),\n instructor=instructor_name,\n instructor_email=instructor_email,\n ge_areas=ge_areas,\n available_seats=response['BLEND_SEATS_AVAIL'],\n wl_length=response['BLEND_WAIT_COUNT'],\n meetings=meetings,\n final_exam=final_exam,\n drop_time=drop_time,\n prerequisites=re.sub(r'\\s+', ' ', response['PREREQUISITES']) if response['PREREQUISITES'] else None)","def remove_empty_courses(self):\n pass","def get_courses(self) -> Tuple[Dict[int, float], Dict[float, List[int]]]:\n\n loop_ids_to_course = {}\n course_to_loop_ids = {0: []}\n current_course_id = 0\n\n # Iterate through the loops\n for current_loop_id in range(self.last_loop_id + 1):\n # Check if there are any parent loops, if there are, then iterate through them\n for parent in self.loops[current_loop_id].parent_loops:\n # If the parent loop is in the course below the current course, there is a course change\n if loop_ids_to_course[parent.loop_id] != current_course_id-1:\n # Course change! Increment course id and create an empty course.\n current_course_id += 1\n course_to_loop_ids[current_course_id] = []\n # Add values to dictionaries\n loop_ids_to_course[current_loop_id] = current_course_id\n course_to_loop_ids[current_course_id].append(current_loop_id)\n\n return(loop_ids_to_course, course_to_loop_ids)","def test_course_filter(self):\n user = self.make_user()\n enrollment = EnrollmentFactory(grade_level__school_year__school=user.school)\n student = enrollment.student\n course_1 = CourseFactory(grade_levels=[enrollment.grade_level])\n course_2 = CourseFactory(grade_levels=[enrollment.grade_level])\n GradeFactory(student=student, graded_work__course_task__course=course_1)\n GradeFactory(student=student, graded_work__course_task__course=course_2)\n url = self.reverse(\"reports:progress\", pk=enrollment.id)\n url += f\"?course={course_1.id}\"\n\n with self.login(user):\n self.get_check_200(url)\n\n assert len(self.get_context(\"courses\")) == 1","def list_course(request, template=\"core/list_course.html\"):\n response = {\n 'morning': Course.objects.at_morning(),\n 'afternoon': Course.objects.at_afternoon(),\n }\n return direct_to_template(request, template, response)","def get_courses(db: Session = Depends(get_db)): # , _: models.User = Depends(get_current_user))\n return crud.course.get_multi(db, skip=0, limit=100)","def __get_emptiest (self, person):\n doubles = []\n for scheduling_unit in person.get_scheduling_units ( ):\n doubles.append ((scheduling_unit, self.__calculate_emptiness (scheduling_unit)))\n \n doubles.sort (key=lambda trio: trio[1])\n \n scheduling_units = []\n for double in doubles:\n scheduling_units.append (double[0])\n \n return scheduling_units","def build_general_course(self):\n\n courses = {}\n\n if self.__build_analyze is False:\n self.build_analysis()\n\n courses[\"taxa_conhecimento\"] = self.analysis[\"taxa_conhecimento\"]\n courses[\"taxa_reprovacao\"] = self.analysis[\"taxa_reprovacao_absoluta\"]\n courses[\"taxa_trancamento\"] = self.analysis[\"taxa_trancamento\"]\n\n # cria cache\n cache = {}\n note = self.analysis[\"general_note_statistic\"]\n for rate_it in self.__rates:\n rate_calc = self.analysis[\"general_rates\"][rate_it.name][0]\n for course in self.analysis[\"courses\"].index:\n if course not in cache:\n cache[course] = {}\n cache[course][rate_it.name] = rate_calc[course]\n cache[course][\"nota\"] = [note[0][course], note[1][course]]\n\n courses[\"cache\"] = cache\n\n # cria o campo compara_aprov\n courses[\"compara_aprov\"] = self.analysis[\"graph_course\"]\n\n # cria o campo courses\n courses[\"disciplinas\"] = self.analysis[\"courses\"].to_dict()\n\n return courses","def get_courses():\n courses = []\n courses_recs = Course._file.read_db()\n for course in courses_recs[\"courses\"]:\n courses.append(Course(**course))\n return courses","def parse_dept(url):\n\n x = lxml.html.parse(url)\n course_roots = x.xpath('//*[@class=\"course\"]')\n\n subcourse_list = []\n\n for course_root in course_roots:\n\n day_elems = course_root.xpath('div//*[@class=\"mtgpat\"]')\n time_elems = course_root.xpath('div//*[@class=\"mtg_time\"]')\n\n for j in range(0, len(day_elems)):\n\n if day_elems[j].text == u'\\xa0' or 'TBA' in day_elems[j].text:\n day_list = []\n else:\n day_list = convert_day(day_elems[j].text)\n if time_elems[j].text == u'\\xa0' or 'TBA' in time_elems[j].text:\n hour_list = []\n else:\n hour_list = convert_time(time_elems[j].text)\n\n subcourse = [day_list, hour_list]\n subcourse_list.append(subcourse)\n\n return subcourse_list","def get_dummy_course(start, announcement=None, is_new=None, advertised_start=None, end=None, certs=False):\r\n\r\n system = DummySystem(load_error_modules=True)\r\n\r\n def to_attrb(n, v):\r\n return '' if v is None else '{0}=\"{1}\"'.format(n, v).lower()\r\n\r\n is_new = to_attrb('is_new', is_new)\r\n announcement = to_attrb('announcement', announcement)\r\n advertised_start = to_attrb('advertised_start', advertised_start)\r\n end = to_attrb('end', end)\r\n\r\n start_xml = '''\r\n <course org=\"{org}\" course=\"{course}\" display_organization=\"{org}_display\" display_coursenumber=\"{course}_display\"\r\n graceperiod=\"1 day\" url_name=\"test\"\r\n start=\"{start}\"\r\n {announcement}\r\n {is_new}\r\n {advertised_start}\r\n {end}\r\n certificates_show_before_end=\"{certs}\">\r\n <chapter url=\"hi\" url_name=\"ch\" display_name=\"CH\">\r\n <html url_name=\"h\" display_name=\"H\">Two houses, ...</html>\r\n </chapter>\r\n </course>\r\n '''.format(org=ORG, course=COURSE, start=start, is_new=is_new,\r\n announcement=announcement, advertised_start=advertised_start, end=end,\r\n certs=certs)\r\n\r\n return system.process_xml(start_xml)","def getTrainTimes(t1,testTimes):\n trn=t1.copy(deep=True)\n for i,j in testTimes.iteritems():\n df0=trn[(i<=trn.index)&(trn.index<=j)].index # train starts within test\n df1=trn[(i<=trn)&(trn<=j)].index # train ends within test\n df2=trn[(trn.index<=i)&(j<=trn)].index # train envelops test\n trn=trn.drop(df0.union(df1).union(df2))\n return trn","def getTimes():","def getTimes():","def getTimes():","def transit_times(self):\n try:\n self._transit_times\n self.nt\n except:\n return np.array([], dtype=float)\n return self._transit_times[:self.nt]","def test_no_courses():\n model = models.Root()\n model.load_local_courses(fixture_path / 'empty-lessons-dir')\n\n assert sorted(model.courses) == ['lessons']\n assert not model.courses['lessons'].sessions\n assert not model.courses['lessons'].lessons","def get_courses_for_wiki(self, wiki_slug):\r\n courses = []\r\n return courses","def anon_acqtimes(dset_dir):\n bl_dt = parser.parse('1800-01-01')\n\n layout = BIDSLayout(dset_dir)\n subjects = layout.get_subjects()\n sessions = sorted(layout.get_sessions())\n\n for sub in subjects:\n if not sessions:\n scans_file = op.join(\n dset_dir, f'sub-{sub}/sub-{sub}_scans.tsv')\n df = pd.read_csv(scans_file, sep='\\t')\n first_scan = df['acq_time'].min()\n first_dt, _ = parser.parse(first_scan.split('T'))\n diff = first_dt - bl_dt\n acq_times = df['acq_time'].apply(parser.parse)\n acq_times = (acq_times - diff).astype(str)\n df['acq_time'] = acq_times\n df.to_csv(scans_file, sep='\\t', line_terminator='\\n',\n na_rep='n/a', index=False)\n else:\n # Separated from dataset sessions in case subject missed some\n sub_ses = sorted(layout.get_sessions(subject=sub))\n for i, ses in enumerate(sub_ses):\n scans_file = op.join(\n dset_dir,\n f'sub-{sub}/ses-{ses}/sub-{sub}_ses-{ses}_scans.tsv')\n df = pd.read_csv(scans_file, sep='\\t')\n if i == 0:\n # Anonymize in terms of first scan for subject.\n first_scan = df['acq_time'].min()\n first_dt = parser.parse(first_scan.split('T')[0])\n diff = first_dt - bl_dt\n\n acq_times = df['acq_time'].apply(parser.parse)\n acq_times = (acq_times - diff).astype(str)\n df['acq_time'] = acq_times\n df.to_csv(scans_file, sep='\\t', line_terminator='\\n',\n na_rep='n/a', index=False)","def get_clinical_trials():\n url = 'http://clinicaltrials.gov/ct2/crawl'\n html = download_web_data(url)\n pages = re.findall(r'href=\"/ct2/crawl/(\\d+)\"', html)\n lnct = set()\n for p in pages:\n html = download_web_data('%s/%s' % (url, p))\n ct = re.findall(r'href=\"/ct2/show/(NCT\\d+)\"', html)\n lnct |= set(ct)\n return sorted(lnct)","def GetTimeCompletenessList(self):\n raise NotImplementedError()","def dtm_coherence(self, time):\n coherence_topics = []\n for topics in self.print_topics(time):\n coherence_topic = []\n for word, dist in topics:\n coherence_topic.append(word)\n coherence_topics.append(coherence_topic)\n\n return coherence_topics","def thetacm(t):\n return np.array([\n 0,\n 0,\n self.wz * t\n ])","def available_courses(self):\r\n def _get_course_name(el):\r\n # The first component in the link text is the course number\r\n _, course_name = el.text.split(' ', 1)\r\n return course_name\r\n\r\n return self.q(css='section.info > hgroup > h3 > a').map(_get_course_name).results","def findNonCriticalAct(listActivities): \n # Find all paths and critical paths\n \n listPaths = find_all_paths(listActivities[0])\n listDurations = []\n for cpt, path in enumerate(listPaths):\n listDurations.append(sum(act.duration for act in path))\n projectDuration = max(listDurations)\n listCriticalPaths = []\n for cpt, path in enumerate(listPaths):\n if listDurations[cpt] == projectDuration:\n listCriticalPaths.append(path)\n listNonCritActs = []\n for act in listActivities:\n if act not in sum(listCriticalPaths, []):\n listNonCritActs.append(act)\n return listNonCritActs","def part2(input):\n ps = PlanetSystem(input)\n c = ps.total_cycle_time()\n return c","def get_course(dept, num):\n \n # semester: 10 = Fall, 20 = Spring, 30 = Summer\n host = \"https://selfservice.mypurdue.purdue.edu/prod/bwckctlg.p_disp_course_detail\"\n query = \"?cat_term_in={term}&subj_code_in={dept}&crse_numb_in={num}\".format(term=\"201620\", dept=dept, num=num)\n urlfetch.set_default_fetch_deadline(600)\n result = urlfetch.fetch(host+query)\n \n if result.status_code == 200:\n tree = html.fromstring(result.content)\n text = tree[1][4][2].text_content() # get just the relevant text of the webpage \n\n # remove unicode non-breaking spaces to allow regexing\n text = text.replace(u'\\xa0',u' ')\n return text","def list_courses_subjects(self, all=False):\n q = {'facet': 'true',\n 'facet.field': 'course_subject',\n 'facet.mincount': '1',\n 'facet.sort': 'index', # Sort alphabetically\n 'rows': '0', # we don't need any actual document\n }\n if all:\n q['q'] = '*:*'\n else:\n q['q'] = 'NOT presentation_start:[* TO NOW]'\n results = searcher.search(q, start=0, count=1000) # Do not paginate\n subjects = subjects_facet_to_subjects_domain(results)\n return subjects","def discretize(self,dt):\n res = self.discretize_state(dt)\n n = len(res.milestones[0])//2\n return Trajectory(res.times,[m[:n] for m in res.milestones])","def get_timepoints(self):\n return list(sorted(self.mdvtc.keys()))","def test_get_full_topic_courses(self):\r\n course_id = None # Change me!!\r\n topic_id = None # Change me!!\r\n\r\n r = self.client.get_full_topic_courses(topic_id, course_id)","def see_teaching_courses(self, username: str, token: str) -> List[Dict[str, object]]:\n\n # Validate user first\n if not self.validate(username=username, token=token, check_privilege='instructor'):\n raise RuntimeError(\"User not verified!\")\n\n # Get UID from user's username\n uid = self.get_uid(username=username)\n\n # Query database for courses instructed by a user with this UID\n cursor = self._db_connection.cursor()\n cursor.execute(\n '''\n SELECT \n course_id,\n course_abbreviation,\n course_name, \n time,\n seats \n FROM \n courses\n WHERE \n instructor_id = ?\n ;\n ''', (uid,))\n\n db_results = cursor.fetchall()\n\n if db_results is None:\n print(\"No associated courses found!\")\n return []\n\n # Build information dicts for every course this user is instructing\n courses = []\n for result in db_results:\n # Get the number of students enrolled in this course already\n cursor.execute('''SELECT COUNT(*) FROM enrollment_records WHERE course_id = ?;''', (result[0],))\n students_enrolled = cursor.fetchone()[0]\n if students_enrolled is None:\n students_enrolled = 0\n\n # Build a course dict from the data\n courses.append({\n \"course_abbreviation\": result[1],\n \"course_name\": result[2],\n \"time\": result[3],\n \"students_enrolled\": students_enrolled,\n \"capacity\": result[4],\n })\n\n return courses","def pc_work_time_total(self):\n return _TestA_swig.cleanslate_sptr_pc_work_time_total(self)","def test_has_course(self):\r\n check_has_course_method(\r\n XMLModuleStore(DATA_DIR, course_dirs=['toy', 'simple']),\r\n SlashSeparatedCourseKey('edX', 'toy', '2012_Fall'),\r\n locator_key_fields=SlashSeparatedCourseKey.KEY_FIELDS\r\n )","def satisfying_courses(self):\n return (\n Course.objects.all()\n .exclude(id__in=self.overrides.all())\n .filter(\n Q(department__in=self.departments.all(), semester=self.semester)\n | Q(id__in=self.courses.all())\n )\n )","def graph_course(self):\n group = self.__data[\"filted_general_groupby\"]\n graph = {}\n if self.analysis[\"courses\"] is None:\n self.courses_list()\n\n # inicializa o dicionario que vai guardar o grafico\n for course in self.analysis[\"courses\"].index:\n graph[course] = []\n\n for i in range(18):\n min_v = i * 5\n max_v = min_v + 4.99\n self.__calc_graph_mean(group, min_v, max_v, graph)\n\n min_v = 95\n max_v = 100\n self.__calc_graph_mean(group, min_v, max_v, graph)\n\n self.analysis[\"graph_course\"] = graph","def test_xblockcompletion_no_data_course(self):\n from lms.djangoapps.courseware.models import StudentModule\n data = {\n 'format':'all'\n }\n response = self.client_instructor.get(reverse('xblockcompletion-data:data'), data)\n self.assertEqual(response.status_code, 200)\n self.assertEqual(json.loads(response._container[0].decode()), {'error': 'Falta parametro course o parametro incorrecto'})","def course_lineup(self):\n return None","def tcvs(self): \n return self._link_reg.tcvs","def get_course(self):\r\n return self.descriptor.runtime.modulestore.get_course(self.course_id)","def get_sorted_courses(self, include_unscheduled=False) -> List[Course]:\n return sorted(\n filter(\n lambda c: c.time is not None or include_unscheduled, self.get_courses()\n ),\n key=lambda c: (0, 0) if not c.time else (c.weekday(), c.time.start),\n )","def year_demand_rule(_m, y):\r\n\r\n return sum(m.SCENARIO_DEMAND[y, s] for s in m.S)","def get_course_ids(self):\n if not self.is_course_based_activity():\n raise IllegalState()\n else:\n raise Unimplemented()","def test_course_listing_performance(self):\r\n # create and log in a non-staff user\r\n self.user = UserFactory()\r\n request = self.factory.get('/course')\r\n request.user = self.user\r\n self.client.login(username=self.user.username, password='test')\r\n\r\n # create list of random course numbers which will be accessible to the user\r\n user_course_ids = random.sample(range(TOTAL_COURSES_COUNT), USER_COURSES_COUNT)\r\n\r\n # create courses and assign those to the user which have their number in user_course_ids\r\n for number in range(TOTAL_COURSES_COUNT):\r\n org = 'Org{0}'.format(number)\r\n course = 'Course{0}'.format(number)\r\n run = 'Run{0}'.format(number)\r\n course_location = SlashSeparatedCourseKey(org, course, run)\r\n if number in user_course_ids:\r\n self._create_course_with_access_groups(course_location, self.user)\r\n else:\r\n self._create_course_with_access_groups(course_location)\r\n\r\n # time the get courses by iterating through all courses\r\n with Timer() as iteration_over_courses_time_1:\r\n courses_list = _accessible_courses_list(request)\r\n self.assertEqual(len(courses_list), USER_COURSES_COUNT)\r\n\r\n # time again the get courses by iterating through all courses\r\n with Timer() as iteration_over_courses_time_2:\r\n courses_list = _accessible_courses_list(request)\r\n self.assertEqual(len(courses_list), USER_COURSES_COUNT)\r\n\r\n # time the get courses by reversing django groups\r\n with Timer() as iteration_over_groups_time_1:\r\n courses_list = _accessible_courses_list_from_groups(request)\r\n self.assertEqual(len(courses_list), USER_COURSES_COUNT)\r\n\r\n # time again the get courses by reversing django groups\r\n with Timer() as iteration_over_groups_time_2:\r\n courses_list = _accessible_courses_list_from_groups(request)\r\n self.assertEqual(len(courses_list), USER_COURSES_COUNT)\r\n\r\n # test that the time taken by getting courses through reversing django groups is lower then the time\r\n # taken by traversing through all courses (if accessible courses are relatively small)\r\n self.assertGreaterEqual(iteration_over_courses_time_1.elapsed, iteration_over_groups_time_1.elapsed)\r\n self.assertGreaterEqual(iteration_over_courses_time_2.elapsed, iteration_over_groups_time_2.elapsed)","def get_course_table(self, table):\n json_result = {}\n row_list = table.xpath('.//table[@id = \"s_course\"]/tr[position() > 1]')\n for row in row_list:\n session = row.xpath('./td[1]/text()')\n course_full_code_list = row.xpath('.//a[starts-with(@href, \"javascript:course_popup\")]/text()')\n course_name_list = row.xpath('.//font[@style = \"font-size:7pt;\"]/text()')\n course_list = []\n if len(course_full_code_list) != len(course_name_list):\n # year course design project would be count twice\n if (\"Design Project\" == course_name_list[0]) & \\\n (len(course_full_code_list) + 1 == len(course_name_list)):\n course_name_list = course_name_list[1:]\n else:\n raise ProfileException(\n \"Error: unmatched lists. course code list:\",\n course_full_code_list, \"\\n course name list:\", course_name_list)\n for i, full_code in enumerate(course_full_code_list):\n if re.match(re.compile('\\w{3}\\d{3}[YH]1\\s+[SFY]'), full_code) is None:\n raise ProfileException(\"Illegal course code!:\" + full_code)\n course_list.append({\n \"courseName\": course_name_list[i],\n \"courseCode\": full_code[0:6],\n \"courseTime\": full_code[-1],\n \"courseLength\": full_code[6:8]\n })\n # there is a empty session\n if session:\n json_result.update({session[0]: course_list})\n if json_result:\n return json_result\n else:\n raise ProfileException(\"Failed to get course_table table(row list is empty)\")","def get_all_teacher_courses(cls, user):\n member_record = CourseMember.objects.filter(user=user)\n member_teacher = member_record.filter(Q(type = 0) | Q(type = 1) | Q(type = 2))\n teacher_list = []\n\n for member in member_teacher:\n if member.course.pk not in teacher_list:\n teacher_list.append(member.course.pk)\n\n return teacher_list","def course(self):\n return self.section.course","def test_xml_get_courses(self):\r\n self.initdb('direct')\r\n courses = self.store.modulestores['xml'].get_courses()\r\n self.assertEqual(len(courses), 2)\r\n course_ids = [course.id for course in courses]\r\n self.assertIn(self.course_locations[self.XML_COURSEID1].course_key, course_ids)\r\n self.assertIn(self.course_locations[self.XML_COURSEID2].course_key, course_ids)\r\n # this course is in the directory from which we loaded courses but not in the map\r\n self.assertNotIn(\"edX/toy/TT_2012_Fall\", course_ids)","def get_cumulative_model(self):\n cm = None\n for ac in self.ac:\n if ac[0] is None:\n continue\n m = self.get_model(last=False, a=ac[0], c=ac[1])\n cm = m if cm is None else cm+m\n return cm","def get_course(self):\n is_draft = self.direct_course.extended_object.publisher_is_draft\n ancestor_nodes = self.direct_course.extended_object.node.get_ancestors()\n return Course.objects.filter(\n # Joining on `cms_pages` generate duplicates for courses that are under a parent page\n # when this page exists both in draft and public versions. We need to exclude the\n # parent public page to avoid this duplication\n Q(\n extended_object__node__cms_pages__publisher_is_draft=is_draft\n ) # course has a parent\n | Q(extended_object__node__isnull=True), # course has no parent\n # Target courses that are ancestors of the course related to the course run\n Q(id=self.direct_course_id) | Q(extended_object__node__in=ancestor_nodes),\n # Exclude snapshots\n extended_object__node__parent__cms_pages__course__isnull=True, # exclude snapshots\n # Get the course in the same version as the course run\n extended_object__publisher_is_draft=is_draft,\n ).distinct()[0]","def get_courses_html():\r\n r = requests.get(URL_CS_ALL_REQ)\r\n if r.status_code == 200:\r\n return r.text\r\n else:\r\n return None","def discretize(self,dt):\n self._skip_deriv = True\n res = self.discretize_state(dt)\n self._skip_deriv = False\n n = self.geodesic.extrinsicDimension()\n return GeodesicTrajectory(self.geodesic,res.times,[m[:n] for m in res.milestones])","def test_import(self):\r\n descriptor = self.get_dummy_course(START)","def extract_ace_data(event, start, stop):\n#\n#--- year of starting time\n#\n atemp = re.split(':', start)\n syear = int(float(atemp[0]))\n atemp = re.split(':', stop)\n eyear = int(float(atemp[0]))\n#\n#--- convert time in Chandra Time\n#\n lstart = start\n start = time.strftime('%Y:%j:%H:%M:00', time.strptime(start, '%Y:%m:%d:%H:%M'))\n stop = time.strftime('%Y:%j:%H:%M:00', time.strptime(stop, '%Y:%m:%d:%H:%M'))\n start = int(Chandra.Time.DateTime(start).secs)\n stop = int(Chandra.Time.DateTime(stop).secs)\n#\n#--- set to data collecting period\n#\n pstart = start - 2 * aday\n period = int((stop - start) / (5 * aday)) + 1\n pstop = start + 5 * period * aday\n\n data = []\n for year in range(syear, eyear+1):\n ifile = data_dir + 'rad_data' + str(syear)\n tdata = mcf.read_data_file(ifile)\n data = data + tdata\n\n hline = 'Science Run Interruption: ' + lstart + '\\n'\n hline = hline + 'dofy electron38 electron175 protont47 proton112 '\n hline = hline + 'proton310 proton761 proton1060 aniso\\n'\n hline = hline + '-' * 100\n\n for ent in data:\n atemp = re.split('\\s+', ent)\n if atemp[0].isdigit():\n ltime = atemp[0] + ':' + atemp[1] + ':' + atemp[2] + ':' + atemp[3]\n ltime = time.strftime('%Y:%j:%H:%M:00', time.strptime(ltime, '%Y:%m:%d:%H%M'))\n stime = int(Chandra.Time.DateTime(ltime).secs)\n if (stime >= pstart) and (stime < pstop):\n hline = hline + '%3.4f\\t' % chandara_time_to_yday(stime, syear) \n hline = hline + atemp[7] + '\\t' + atemp[8] + '\\t'\n hline = hline + atemp[10] + '\\t' + atemp[11] + '\\t'\n hline = hline + atemp[12] + '\\t' + atemp[13] + '\\t'\n hline = hline + atemp[14] + '\\t' + atemp[15] + '\\n'\n\n#\n#--- print out the data\n#\n ofile = wdata_dir + event + '_dat.txt'\n\n with open(ofile, 'w') as fo:\n fo.write(hline)","def _find_memberless_constituencies(self):\n constituencies = Constituency.objects.filter(\n end=None, # Constituency currently exists/is not historical\n mp=None,\n )\n\n self.stdout('Constituencies with missing MP:')\n for constituency in constituencies:\n self.stdout(f'[{constituency.parliamentdotuk}] {constituency.name} {constituency.start}')","def trial_wtd(trial, omit_missing_frames=True):\n x = np.arange(len(trial.HMM_MLE))/60\n y = (trial.HMM_MLE == 0)\n if omit_missing_frames:\n x = x[trial.HMM_MLE >= 0]\n y = y[trial.HMM_MLE >= 0]\n return linear_regression_with_CIs(x/60, y, return_CIs=False)","def get_course(self, _):\r\n courses = self.modulestore.get_courses()\r\n return courses[0]","def threat(year, clock):\n # find latest adjustment preceding or equal to the given year\n index = -1\n while clock[index][0] > year:\n index -= 1\n # return time set at latest adjustment\n return clock[index][1]","def get_detailed_ddct_data(self, assay):\n df = self.ddct.query(\"Assay == '{}'\".format(assay)).reset_index(drop=True)\n return pandas.pivot_table(df, values=0, columns='time', index=['cell_line', 'treatment', 'replicate'])","def get_units_with_due_date(course):\r\n units = []\r\n\r\n def visit(node):\r\n \"\"\"\r\n Visit a node. Checks to see if node has a due date and appends to\r\n `units` if it does. Otherwise recurses into children to search for\r\n nodes with due dates.\r\n \"\"\"\r\n if getattr(node, 'due', None):\r\n units.append(node)\r\n else:\r\n for child in node.get_children():\r\n visit(child)\r\n visit(course)\r\n #units.sort(key=_title_or_url)\r\n return units","def get_past_ec(self, timestep):\n df = DataFrame(list(self.ec_db.find({'time': timestep})))\n df.index = df.ec\n return df","def requested_courses(self, user_id: str) -> np.ndarray:\n self.retrieve_leads()\n\n return self.leads_df[self.leads_df['user_id'] == user_id]['course_id'].values","def test_get_course_list(self):\r\n request = self.factory.get('/course/')\r\n request.user = self.user\r\n\r\n course_location = SlashSeparatedCourseKey('Org1', 'Course1', 'Run1')\r\n self._create_course_with_access_groups(course_location, self.user)\r\n\r\n # get courses through iterating all courses\r\n courses_list = _accessible_courses_list(request)\r\n self.assertEqual(len(courses_list), 1)\r\n\r\n # get courses by reversing group name formats\r\n courses_list_by_groups = _accessible_courses_list_from_groups(request)\r\n self.assertEqual(len(courses_list_by_groups), 1)\r\n # check both course lists have same courses\r\n self.assertEqual(courses_list, courses_list_by_groups)","def test_returns_concurrent_meeting_time(self):\n result = meeting_planner([[10, 50], [60, 120], [140, 210]], [[0, 15], [60, 70]], 8)\n self.assertEqual(result, [60, 68])","def get_add_years(course):\n # Add 1 year if verification happens during fall, 0 if during spring.\n add_years = 1 if timezone.now().month >= 7 else 0\n\n if course['id'] == GROUP_IDENTIFIERS['PROSJEKT1']:\n add_years += 1\n elif course['id'] == GROUP_IDENTIFIERS['ALGDAT']:\n add_years += 1\n elif course['id'] == GROUP_IDENTIFIERS['PROSJEKT2']:\n add_years += 3\n\n return min(3, add_years)","def get_time_step_values(self):\n return OcTreeReader.get_time_step_values(self)","def get_timesteps(cur):\n info = cur.execute('SELECT initialyear, initialmonth, '\n 'duration FROM info').fetchone()\n init_year = info['initialyear']\n init_month = info['initialmonth']\n duration = info['duration']\n timestep = np.linspace(0, duration - 1, num=duration)\n\n return init_year, init_month, duration, timestep","def pc_work_time_avg(self):\n return _TestA_swig.cleanslate_sptr_pc_work_time_avg(self)","def get_total_course_completions_for_time_period(site, end_date, **_kwargs):\n return total_site_certificates_as_of_date(site=site, date_for=end_date)"],"string":"[\n \"def _load_timecourses(self):\\n # load the timecourses file\\n tcsf = fetch_one_file(self.ica_dir, self._tcs_fname)\\n tcs = niimg.load_img(tcsf).get_data()\\n return tcs\",\n \"def _load_timecourses(self):\\n # load the timecourses file\\n tcsf = fetch_one_file(self.ica_dir, self._tcs_fname, pat_type='re.match')\\n tcs = niimg.load_img(tcsf).get_data()\\n return tcs\",\n \"def get_timecourse_data(self, fragment, number):\\n timepoints = self.get_timepoints()\\n timecourse = []\\n for time in timepoints:\\n if self.mdvtc[time].has_data(fragment, number):\\n ratio, stdev, use = self.mdvtc[time].get_data(fragment, number)\\n timecourse.append(ratio)\\n return timecourse\",\n \"def test_list_grading_periods_courses(self):\\r\\n course_id = None # Change me!!\\r\\n\\r\\n r = self.client.list_grading_periods_courses(course_id)\",\n \"def get_courses(std):\\n return std[2]\",\n \"def get_courses(self):\\r\\n\\r\\n return self.def_ms.get_courses()\",\n \"def extract_courses():\\n if settings.XPRO_COURSES_API_URL:\\n return requests.get(settings.XPRO_COURSES_API_URL, timeout=20).json()\\n return []\",\n \"def build_course(self):\\n courses = []\\n aprovacao_d = {}\\n # semestral\\n for rate_it in self.__semestral_rate:\\n # pega uma lista no qual o primeiro elemento é a taxa, o segundo\\n # e o terceiro são quantidades\\n rate_data = self.analysis[\\\"semestral_rate\\\"][rate_it.name]\\n for i in rate_data[0].index:\\n if i[0] not in aprovacao_d:\\n aprovacao_d[i[0]] = {}\\n\\n periodo = str(i[1]) + \\\"/\\\" + str(i[2])\\n aprovacao_d[i[0]][periodo] = [\\n float(rate_data[0][i]),\\n int(rate_data[1][i]),\\n int(rate_data[2][i]),]\\n\\n note = self.analysis[\\\"general_note_statistic\\\"]\\n note_last_year = self.analysis[\\\"last_year_statistic\\\"]\\n for course in self.analysis[\\\"courses\\\"].index:\\n course_dict = {}\\n course_dict[\\\"disciplina_codigo\\\"] = course\\n course_dict[\\\"disciplina_nome\\\"] = self.analysis[\\\"courses\\\"][course]\\n \\n # If the course code is related to more than one name,\\n # concatenate these names into an unique string\\n if type(course_dict[\\\"disciplina_nome\\\"]) != str:\\n new_course_name = \\\" | \\\".join(list(course_dict[\\\"disciplina_nome\\\"]))\\n course_dict[\\\"disciplina_nome\\\"] = new_course_name\\n # quantidade de matriculas\\n count = self.analysis[\\\"general_count_submission\\\"][course]\\n course_dict[\\\"qtd_alunos\\\"] = count\\n # notas\\n course_dict[\\\"qtd_cursada_aprov\\\"] = self.analysis[\\\"coursed_ratio\\\"][course]\\n course_dict[\\\"nota\\\"] = [note[0][course], note[1][course]]\\n course_dict[\\\"nota_ultimo_ano\\\"] = [\\n note_last_year[0][course],\\n note_last_year[1][course]\\n ]\\n # taxas\\n for rate_it in self.__rates:\\n rate_data = self.analysis[\\\"general_rates\\\"][rate_it.name]\\n course_dict[rate_it.name] = float(rate_data[0][course])\\n course_str = rate_it.name.replace(\\\"taxa\\\", \\\"qtd\\\")\\n # count_sel define qual quantidade vai para o json, a especifica\\n # ou geral\\n course_dict[course_str] = int(\\n rate_data[rate_it.count_sel][course])\\n # rate_calc = self.analysis[\\\"general_rates\\\"][rate_it.name][0]\\n\\n # taxas do ultimo anos\\n course_dict[\\\"taxa_reprovacao_ultimo_absoluto\\\"] = self.analysis[\\\"last_year_taxa_reprovacao_absoluta\\\"][course]\\n course_dict[\\\"taxa_reprovacao_ultimo_frequencia\\\"] = self.analysis[\\\"last_year_taxa_reprovacao_frequencia\\\"][course]\\n\\n course_dict[\\\"grafico_qtd_cursada_aprov\\\"] = self.analysis[\\\"coursed_count\\\"][course]\\n course_dict[\\\"aprovacao_semestral\\\"] = aprovacao_d[course]\\n courses.append(course_dict)\\n return courses\",\n \"def upcoming_courses(aud):\\n \\n courses = [c for c in aud.all_courses() if c.grade == u\\\"*\\\"]\\n return [c.number.replace(\\\"-\\\", \\\"\\\") for c in courses]\",\n \"def calculate_ddct(self, baseline_time=0):\\n\\n if baseline_time == 0:\\n baseline = self.baseline_data['dct'][0]\\n\\n elif baseline_time == 96:\\n baseline = self.baseline_data['dct'][96]\\n\\n elif baseline_time == 'average':\\n baseline = (self.baseline_data['dct'][0] + self.baseline_data['dct'][96]) / 2\\n\\n control =self.treatment_data.query('treatment == \\\"Control\\\"')['dct']\\n tgf = self.treatment_data.query('treatment == \\\"TGFb\\\"')['dct']\\n control.index = control.index.droplevel(1)\\n tgf.index = tgf.index.droplevel(1)\\n baseline.index = baseline.index.droplevel(1)\\n\\n time = control.columns\\n\\n tgf = pandas.concat([tgf[i]/baseline for i in tgf.columns], axis=1)\\n control = pandas.concat([control[i]/baseline for i in control.columns], axis=1)\\n\\n control.columns = time\\n tgf.columns = time\\n\\n control = pandas.DataFrame(control.stack())\\n tgf = pandas.DataFrame(tgf.stack())\\n control['treatment'] = 'Control'\\n tgf['treatment'] = 'TGFb'\\n df = pandas.concat([control, tgf]).reset_index()\\n df.rename(columns={0: 'ddct'})\\n return df\",\n \"def get_course(data):\\n\\n return {item['course'] for item in data}\",\n \"def ensemble_times(self):\\n return self['validtime'].values\",\n \"def test_find_cycles_no_cycle(self):\\n self._build_sample_graph()\\n skill_map = SkillMap.load(self.course)\\n self.assertEqual(SkillMapMetrics(skill_map).simple_cycles(), [])\",\n \"def get_courses(self):\\n if not self.is_course_based_activity():\\n raise IllegalState()\\n else:\\n raise Unimplemented()\",\n \"def get_courses(self, depth=0):\\r\\n return self.courses.values()\",\n \"def get_time_slices(self):\\n tot = []\\n for clu in self._clusters:\\n tot.extend(self._clusters[clu].to_dict()[:])\\n #tot.sort()\\n return tot\",\n \"def prepare_courses_for_radio():\\n\\n three_closest_courses = get_four_future_courses()\\n radio_courses = []\\n\\n for course in three_closest_courses:\\n radio_courses.append(\\n (int(course.id), str(reformat_date(course.startDate) + ' r.'))\\n )\\n return radio_courses\",\n \"def assembly_courses(wall):\\n courses = []\\n vertices = set(wall.nodes())\\n base = set(wall.nodes_where({'is_support': True}))\\n\\n if base:\\n courses.append(list(base))\\n\\n seen = set()\\n seen.update(base)\\n\\n vertices -= base\\n\\n while vertices:\\n nbrs = set(nbr for key in courses[-1] for nbr in wall.neighbors(key))\\n course = list(nbrs - seen)\\n courses.append(course)\\n seen.update(nbrs)\\n vertices -= nbrs\\n\\n return courses\",\n \"def get_courses(self, *args):\\n courses = []\\n user = self.context['user']\\n modules = user.profile.purchased_modules.all()\\n for module in modules:\\n course_id = self.course_in_courses(module.course.mnemo, courses)\\n if course_id:\\n courses[course_id[0]]['modules'].append({'mnemo': module.mnemo})\\n else:\\n courses.append({\\n 'mnemo': module.course.mnemo,\\n 'modules': [{'mnemo': module.mnemo}]\\n })\\n return courses\",\n \"def get_courses_info(url, headers):\\n dash = get_page_contents(url, headers)\\n soup = BeautifulSoup(dash)\\n courses_soup = soup.find_all('article', 'course')\\n courses = []\\n for course_soup in courses_soup:\\n course_id = None\\n course_name = course_soup.h3.text.strip()\\n course_url = None\\n course_state = 'Not yet'\\n try:\\n # started courses include the course link in the href attribute\\n course_url = BASE_URL + course_soup.a['href']\\n if course_url.endswith('info') or course_url.endswith('info/'):\\n course_state = 'Started'\\n # The id of a course in edX is composed by the path\\n # {organization}/{course_number}/{course_run]\\n course_id = course_soup.a['href'][9:-5]\\n except KeyError:\\n pass\\n courses.append(Course(id=course_id,\\n name=course_name,\\n url=course_url,\\n state=course_state))\\n return courses\",\n \"def get_errored_courses(self):\\r\\n return {}\",\n \"def critical_periods(t, unit='yr'):\\n Nsamp = len(t)\\n T = duration(t, unit)\\n f_nyquist_eq = 0.5/(T/Nsamp)\\n f_nyquist_med = median_nyquist(t, unit)\\n return { 'duration' : T, \\n 'nyquist_eq' : 1.0/f_nyquist_eq,\\n 'nyquist_med' : 1.0/f_nyquist_med }\",\n \"def get_courses(self):\\n\\n self.search([]).unlink()\\n token = self.env['odoo.moodle'].search([('create_uid', '=', self.env.user.id)]).token\\n domain = \\\"http://localhost:8888\\\"\\n webservice_url = \\\"/webservice/rest/server.php?\\\"\\n parameters = {\\n \\\"wstoken\\\":token,\\n 'wsfunction': 'core_course_get_courses',\\n 'moodlewsrestformat': 'json'\\n }\\n request = requests.get(url=domain+webservice_url, params=parameters)\\n request = request.json()\\n print(request)\\n\\n for req in request:\\n try:\\n if req['id']==1:\\n pass\\n else:\\n self.create({\\n 'course_id': req['id'], \\n 'category':req['categoryid'],\\n 'fullname':req['fullname'], \\n 'shortname':req['shortname'],\\n 'summary': req['summary']\\n }\\n )\\n except Exception:\\n print('Course not created')\",\n \"def test_only_students_courses(self):\\n user = self.make_user()\\n enrollment = EnrollmentFactory(grade_level__school_year__school=user.school)\\n course = CourseFactory(grade_levels=[enrollment.grade_level])\\n grade = GradeFactory(\\n score=50,\\n student=enrollment.student,\\n graded_work__course_task__course=course,\\n )\\n grade_2 = GradeFactory(\\n score=100,\\n student=enrollment.student,\\n graded_work__course_task__course=course,\\n )\\n GradeFactory(\\n graded_work__course_task__course__grade_levels=[enrollment.grade_level]\\n )\\n\\n with self.login(user):\\n self.get_check_200(\\\"reports:progress\\\", pk=enrollment.id)\\n\\n assert self.get_context(\\\"courses\\\") == [\\n {\\n \\\"course\\\": grade.graded_work.course_task.course,\\n \\\"grades\\\": [grade, grade_2],\\n \\\"course_average\\\": 75,\\n }\\n ]\",\n \"def get_dummy_course(start):\\r\\n\\r\\n system = DummyImportSystem(load_error_modules=True)\\r\\n\\r\\n def to_attrb(n, v):\\r\\n return '' if v is None else '{0}=\\\"{1}\\\"'.format(n, v).lower()\\r\\n\\r\\n start_xml = '''\\r\\n <course org=\\\"{org}\\\" course=\\\"{course}\\\"\\r\\n graceperiod=\\\"1 day\\\" url_name=\\\"test\\\"\\r\\n start=\\\"{start}\\\"\\r\\n >\\r\\n <chapter url=\\\"hi\\\" url_name=\\\"ch\\\" display_name=\\\"CH\\\">\\r\\n <randomize url_name=\\\"my_randomize\\\">\\r\\n <html url_name=\\\"a\\\" display_name=\\\"A\\\">Two houses, ...</html>\\r\\n <html url_name=\\\"b\\\" display_name=\\\"B\\\">Three houses, ...</html>\\r\\n </randomize>\\r\\n </chapter>\\r\\n </course>\\r\\n '''.format(org=ORG, course=COURSE, start=start)\\r\\n\\r\\n return system.process_xml(start_xml)\",\n \"def course_options(self):\\n return {\\n 'start': datetime.now() - timedelta(days=1)\\n }\",\n \"def emissions_baseline(self):\\n baseline = DataFrame(columns=[\\\"CO2\\\", \\\"NOx\\\", \\\"PM10\\\", \\\"PM2.5\\\", \\\"SO2\\\"])\\n baseline = baseline.append(year_1(self.plant.emissions()))\\n baseline = baseline.append(year_1(self.plant.fuel_reseller().emissions()))\\n baseline = baseline.append(year_1(self.farmer.emissions_exante))\\n baseline.loc[\\\"Total\\\"] = baseline.sum()\\n baseline.loc[\\\"Total_plant\\\"] = baseline.iloc[0]\\n baseline.loc[\\\"Total_transport\\\"] = baseline.iloc[1]\\n baseline.loc[\\\"Total_field\\\"] = baseline.iloc[2]\\n return baseline\",\n \"def get_product_courses(product):\\n if product.content_type.model == CONTENT_TYPE_MODEL_COURSERUN:\\n return [product.content_object.course]\\n elif product.content_type.model == CONTENT_TYPE_MODEL_COURSE:\\n return [product.content_object]\\n elif product.content_type.model == CONTENT_TYPE_MODEL_PROGRAM:\\n return list(\\n product.content_object.courses.all().order_by(\\\"position_in_program\\\")\\n )\",\n \"def calc_total_course_duration(timestamps):\\n dt_conversion = [datetime.strptime(ts, '%M:%S') for ts in timestamps]\\n baseline = datetime(1900, 1, 1, 0, 0, 0)\\n for course_dt in dt_conversion:\\n baseline = baseline + timedelta(minutes=course_dt.minute, seconds=course_dt.second) \\n\\n return baseline.strftime('%-H:%M:%S')\",\n \"def test_delete_grading_period_courses(self):\\r\\n course_id = None # Change me!!\\r\\n id = None # Change me!!\\r\\n\\r\\n r = self.client.delete_grading_period_courses(id, course_id)\",\n \"def phases(self,dataset):\\n start = '1984-1-1'\\n if dataset == \\\"ISCCP_raw\\\":\\n stop = '2007-12-31'\\n else:\\n stop = '2009-12-31'\\n X = getattr(self,dataset)(time=(start,stop))\\n R,P = sc.fast_annual_cycle(X)\\n return MV.masked_where(np.isnan(P),P)\",\n \"def _course_from_query_response(self, term, response):\\n units_low, units_hi = float(response['UNITS_LOW']), float(response['UNITS_HIGH'])\\n if units_low > units_hi:\\n # Yes, this is an actual response case...\\n # Occurs when a course has a constant # of units.\\n # I think units_hi should equal units_low when actual units is constant.\\n units_hi = units_low\\n\\n instructor_name = instructor_email = None\\n try:\\n instructor_meta = next(instr for instr in response['INSTRUCTORS'] if instr['PRIMARY_IND'] == 'Y')\\n instructor_name = '{} {}'.format(instructor_meta['FIRST_NAME'], instructor_meta['LAST_NAME'])\\n instructor_name = instructor_name.strip()\\n instructor_email = instructor_meta['EMAIL']\\n except StopIteration:\\n # No instructor specified\\n pass\\n\\n ge_areas = list()\\n try:\\n area_codes = filter(None, response['GE3CREDIT'].split(','))\\n ge_areas = [GE_AREA_NAMES_BY_SB_CODE[area_code] for area_code in area_codes]\\n except KeyError as e:\\n logging.exception('Unrecognized GE code')\\n\\n meetings = list()\\n for meeting in response['COURSEMEETINGDATA']:\\n days = meeting['WEEKDAYS'].replace(',', '')\\n times = None\\n try:\\n begin_hour, begin_minutes = meeting['BEGIN_TIME'][:2], meeting['BEGIN_TIME'][2:]\\n end_hour, end_minutes = meeting['END_TIME'][:2], meeting['END_TIME'][2:]\\n begin = timedelta(hours=int(begin_hour), minutes=int(begin_minutes))\\n end = timedelta(hours=int(end_hour), minutes=int(end_minutes))\\n times = (begin, end)\\n except TypeError:\\n # times are None, indicating TBA\\n pass\\n\\n location = meeting['BLDG_DESC']\\n if meeting['ROOM']:\\n location += ' ' + meeting['ROOM']\\n\\n meeting = {\\n 'days': days,\\n 'times': times,\\n 'location': location,\\n 'type': meeting['MEET_TYPE_DESC_SHORT']\\n }\\n meetings.append(meeting)\\n\\n final_exam = None\\n try:\\n final_exam = datetime.strptime(response['FINALEXAMSTARTDATE'], '%B, %d %Y %H:%M:%S')\\n except TypeError:\\n # No final exam\\n pass\\n\\n drop_time = response['ALLOWEDDROPDESC']\\n drop_days_match = re.match(r'^([0-9]+)', drop_time)\\n if drop_days_match:\\n drop_time = int(drop_days_match.group(1))\\n if response['DESCRIPTION']:\\n response['DESCRIPTION'] = response['DESCRIPTION'].replace('\\\\n', ' ').replace('\\\\r', '').strip()\\n response['TITLE'] = response['TITLE'].strip()\\n\\n return Course(\\n term=term,\\n crn=response['PASSEDCRN'],\\n subject_code=response['SUBJECT_CODE'],\\n name='{} {}'.format(response['SUBJECT_CODE'], response['COURSE_NUMBER']),\\n number=response['COURSE_NUMBER'],\\n section=response['SEC'],\\n title=response['TITLE'].strip(),\\n description=response['DESCRIPTION'],\\n instructor_consent_required=bool(int(response['CONSENTOFINSRUCTORREQUIRED'])),\\n units=(units_low, units_hi),\\n instructor=instructor_name,\\n instructor_email=instructor_email,\\n ge_areas=ge_areas,\\n available_seats=response['BLEND_SEATS_AVAIL'],\\n wl_length=response['BLEND_WAIT_COUNT'],\\n meetings=meetings,\\n final_exam=final_exam,\\n drop_time=drop_time,\\n prerequisites=re.sub(r'\\\\s+', ' ', response['PREREQUISITES']) if response['PREREQUISITES'] else None)\",\n \"def remove_empty_courses(self):\\n pass\",\n \"def get_courses(self) -> Tuple[Dict[int, float], Dict[float, List[int]]]:\\n\\n loop_ids_to_course = {}\\n course_to_loop_ids = {0: []}\\n current_course_id = 0\\n\\n # Iterate through the loops\\n for current_loop_id in range(self.last_loop_id + 1):\\n # Check if there are any parent loops, if there are, then iterate through them\\n for parent in self.loops[current_loop_id].parent_loops:\\n # If the parent loop is in the course below the current course, there is a course change\\n if loop_ids_to_course[parent.loop_id] != current_course_id-1:\\n # Course change! Increment course id and create an empty course.\\n current_course_id += 1\\n course_to_loop_ids[current_course_id] = []\\n # Add values to dictionaries\\n loop_ids_to_course[current_loop_id] = current_course_id\\n course_to_loop_ids[current_course_id].append(current_loop_id)\\n\\n return(loop_ids_to_course, course_to_loop_ids)\",\n \"def test_course_filter(self):\\n user = self.make_user()\\n enrollment = EnrollmentFactory(grade_level__school_year__school=user.school)\\n student = enrollment.student\\n course_1 = CourseFactory(grade_levels=[enrollment.grade_level])\\n course_2 = CourseFactory(grade_levels=[enrollment.grade_level])\\n GradeFactory(student=student, graded_work__course_task__course=course_1)\\n GradeFactory(student=student, graded_work__course_task__course=course_2)\\n url = self.reverse(\\\"reports:progress\\\", pk=enrollment.id)\\n url += f\\\"?course={course_1.id}\\\"\\n\\n with self.login(user):\\n self.get_check_200(url)\\n\\n assert len(self.get_context(\\\"courses\\\")) == 1\",\n \"def list_course(request, template=\\\"core/list_course.html\\\"):\\n response = {\\n 'morning': Course.objects.at_morning(),\\n 'afternoon': Course.objects.at_afternoon(),\\n }\\n return direct_to_template(request, template, response)\",\n \"def get_courses(db: Session = Depends(get_db)): # , _: models.User = Depends(get_current_user))\\n return crud.course.get_multi(db, skip=0, limit=100)\",\n \"def __get_emptiest (self, person):\\n doubles = []\\n for scheduling_unit in person.get_scheduling_units ( ):\\n doubles.append ((scheduling_unit, self.__calculate_emptiness (scheduling_unit)))\\n \\n doubles.sort (key=lambda trio: trio[1])\\n \\n scheduling_units = []\\n for double in doubles:\\n scheduling_units.append (double[0])\\n \\n return scheduling_units\",\n \"def build_general_course(self):\\n\\n courses = {}\\n\\n if self.__build_analyze is False:\\n self.build_analysis()\\n\\n courses[\\\"taxa_conhecimento\\\"] = self.analysis[\\\"taxa_conhecimento\\\"]\\n courses[\\\"taxa_reprovacao\\\"] = self.analysis[\\\"taxa_reprovacao_absoluta\\\"]\\n courses[\\\"taxa_trancamento\\\"] = self.analysis[\\\"taxa_trancamento\\\"]\\n\\n # cria cache\\n cache = {}\\n note = self.analysis[\\\"general_note_statistic\\\"]\\n for rate_it in self.__rates:\\n rate_calc = self.analysis[\\\"general_rates\\\"][rate_it.name][0]\\n for course in self.analysis[\\\"courses\\\"].index:\\n if course not in cache:\\n cache[course] = {}\\n cache[course][rate_it.name] = rate_calc[course]\\n cache[course][\\\"nota\\\"] = [note[0][course], note[1][course]]\\n\\n courses[\\\"cache\\\"] = cache\\n\\n # cria o campo compara_aprov\\n courses[\\\"compara_aprov\\\"] = self.analysis[\\\"graph_course\\\"]\\n\\n # cria o campo courses\\n courses[\\\"disciplinas\\\"] = self.analysis[\\\"courses\\\"].to_dict()\\n\\n return courses\",\n \"def get_courses():\\n courses = []\\n courses_recs = Course._file.read_db()\\n for course in courses_recs[\\\"courses\\\"]:\\n courses.append(Course(**course))\\n return courses\",\n \"def parse_dept(url):\\n\\n x = lxml.html.parse(url)\\n course_roots = x.xpath('//*[@class=\\\"course\\\"]')\\n\\n subcourse_list = []\\n\\n for course_root in course_roots:\\n\\n day_elems = course_root.xpath('div//*[@class=\\\"mtgpat\\\"]')\\n time_elems = course_root.xpath('div//*[@class=\\\"mtg_time\\\"]')\\n\\n for j in range(0, len(day_elems)):\\n\\n if day_elems[j].text == u'\\\\xa0' or 'TBA' in day_elems[j].text:\\n day_list = []\\n else:\\n day_list = convert_day(day_elems[j].text)\\n if time_elems[j].text == u'\\\\xa0' or 'TBA' in time_elems[j].text:\\n hour_list = []\\n else:\\n hour_list = convert_time(time_elems[j].text)\\n\\n subcourse = [day_list, hour_list]\\n subcourse_list.append(subcourse)\\n\\n return subcourse_list\",\n \"def get_dummy_course(start, announcement=None, is_new=None, advertised_start=None, end=None, certs=False):\\r\\n\\r\\n system = DummySystem(load_error_modules=True)\\r\\n\\r\\n def to_attrb(n, v):\\r\\n return '' if v is None else '{0}=\\\"{1}\\\"'.format(n, v).lower()\\r\\n\\r\\n is_new = to_attrb('is_new', is_new)\\r\\n announcement = to_attrb('announcement', announcement)\\r\\n advertised_start = to_attrb('advertised_start', advertised_start)\\r\\n end = to_attrb('end', end)\\r\\n\\r\\n start_xml = '''\\r\\n <course org=\\\"{org}\\\" course=\\\"{course}\\\" display_organization=\\\"{org}_display\\\" display_coursenumber=\\\"{course}_display\\\"\\r\\n graceperiod=\\\"1 day\\\" url_name=\\\"test\\\"\\r\\n start=\\\"{start}\\\"\\r\\n {announcement}\\r\\n {is_new}\\r\\n {advertised_start}\\r\\n {end}\\r\\n certificates_show_before_end=\\\"{certs}\\\">\\r\\n <chapter url=\\\"hi\\\" url_name=\\\"ch\\\" display_name=\\\"CH\\\">\\r\\n <html url_name=\\\"h\\\" display_name=\\\"H\\\">Two houses, ...</html>\\r\\n </chapter>\\r\\n </course>\\r\\n '''.format(org=ORG, course=COURSE, start=start, is_new=is_new,\\r\\n announcement=announcement, advertised_start=advertised_start, end=end,\\r\\n certs=certs)\\r\\n\\r\\n return system.process_xml(start_xml)\",\n \"def getTrainTimes(t1,testTimes):\\n trn=t1.copy(deep=True)\\n for i,j in testTimes.iteritems():\\n df0=trn[(i<=trn.index)&(trn.index<=j)].index # train starts within test\\n df1=trn[(i<=trn)&(trn<=j)].index # train ends within test\\n df2=trn[(trn.index<=i)&(j<=trn)].index # train envelops test\\n trn=trn.drop(df0.union(df1).union(df2))\\n return trn\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def transit_times(self):\\n try:\\n self._transit_times\\n self.nt\\n except:\\n return np.array([], dtype=float)\\n return self._transit_times[:self.nt]\",\n \"def test_no_courses():\\n model = models.Root()\\n model.load_local_courses(fixture_path / 'empty-lessons-dir')\\n\\n assert sorted(model.courses) == ['lessons']\\n assert not model.courses['lessons'].sessions\\n assert not model.courses['lessons'].lessons\",\n \"def get_courses_for_wiki(self, wiki_slug):\\r\\n courses = []\\r\\n return courses\",\n \"def anon_acqtimes(dset_dir):\\n bl_dt = parser.parse('1800-01-01')\\n\\n layout = BIDSLayout(dset_dir)\\n subjects = layout.get_subjects()\\n sessions = sorted(layout.get_sessions())\\n\\n for sub in subjects:\\n if not sessions:\\n scans_file = op.join(\\n dset_dir, f'sub-{sub}/sub-{sub}_scans.tsv')\\n df = pd.read_csv(scans_file, sep='\\\\t')\\n first_scan = df['acq_time'].min()\\n first_dt, _ = parser.parse(first_scan.split('T'))\\n diff = first_dt - bl_dt\\n acq_times = df['acq_time'].apply(parser.parse)\\n acq_times = (acq_times - diff).astype(str)\\n df['acq_time'] = acq_times\\n df.to_csv(scans_file, sep='\\\\t', line_terminator='\\\\n',\\n na_rep='n/a', index=False)\\n else:\\n # Separated from dataset sessions in case subject missed some\\n sub_ses = sorted(layout.get_sessions(subject=sub))\\n for i, ses in enumerate(sub_ses):\\n scans_file = op.join(\\n dset_dir,\\n f'sub-{sub}/ses-{ses}/sub-{sub}_ses-{ses}_scans.tsv')\\n df = pd.read_csv(scans_file, sep='\\\\t')\\n if i == 0:\\n # Anonymize in terms of first scan for subject.\\n first_scan = df['acq_time'].min()\\n first_dt = parser.parse(first_scan.split('T')[0])\\n diff = first_dt - bl_dt\\n\\n acq_times = df['acq_time'].apply(parser.parse)\\n acq_times = (acq_times - diff).astype(str)\\n df['acq_time'] = acq_times\\n df.to_csv(scans_file, sep='\\\\t', line_terminator='\\\\n',\\n na_rep='n/a', index=False)\",\n \"def get_clinical_trials():\\n url = 'http://clinicaltrials.gov/ct2/crawl'\\n html = download_web_data(url)\\n pages = re.findall(r'href=\\\"/ct2/crawl/(\\\\d+)\\\"', html)\\n lnct = set()\\n for p in pages:\\n html = download_web_data('%s/%s' % (url, p))\\n ct = re.findall(r'href=\\\"/ct2/show/(NCT\\\\d+)\\\"', html)\\n lnct |= set(ct)\\n return sorted(lnct)\",\n \"def GetTimeCompletenessList(self):\\n raise NotImplementedError()\",\n \"def dtm_coherence(self, time):\\n coherence_topics = []\\n for topics in self.print_topics(time):\\n coherence_topic = []\\n for word, dist in topics:\\n coherence_topic.append(word)\\n coherence_topics.append(coherence_topic)\\n\\n return coherence_topics\",\n \"def thetacm(t):\\n return np.array([\\n 0,\\n 0,\\n self.wz * t\\n ])\",\n \"def available_courses(self):\\r\\n def _get_course_name(el):\\r\\n # The first component in the link text is the course number\\r\\n _, course_name = el.text.split(' ', 1)\\r\\n return course_name\\r\\n\\r\\n return self.q(css='section.info > hgroup > h3 > a').map(_get_course_name).results\",\n \"def findNonCriticalAct(listActivities): \\n # Find all paths and critical paths\\n \\n listPaths = find_all_paths(listActivities[0])\\n listDurations = []\\n for cpt, path in enumerate(listPaths):\\n listDurations.append(sum(act.duration for act in path))\\n projectDuration = max(listDurations)\\n listCriticalPaths = []\\n for cpt, path in enumerate(listPaths):\\n if listDurations[cpt] == projectDuration:\\n listCriticalPaths.append(path)\\n listNonCritActs = []\\n for act in listActivities:\\n if act not in sum(listCriticalPaths, []):\\n listNonCritActs.append(act)\\n return listNonCritActs\",\n \"def part2(input):\\n ps = PlanetSystem(input)\\n c = ps.total_cycle_time()\\n return c\",\n \"def get_course(dept, num):\\n \\n # semester: 10 = Fall, 20 = Spring, 30 = Summer\\n host = \\\"https://selfservice.mypurdue.purdue.edu/prod/bwckctlg.p_disp_course_detail\\\"\\n query = \\\"?cat_term_in={term}&subj_code_in={dept}&crse_numb_in={num}\\\".format(term=\\\"201620\\\", dept=dept, num=num)\\n urlfetch.set_default_fetch_deadline(600)\\n result = urlfetch.fetch(host+query)\\n \\n if result.status_code == 200:\\n tree = html.fromstring(result.content)\\n text = tree[1][4][2].text_content() # get just the relevant text of the webpage \\n\\n # remove unicode non-breaking spaces to allow regexing\\n text = text.replace(u'\\\\xa0',u' ')\\n return text\",\n \"def list_courses_subjects(self, all=False):\\n q = {'facet': 'true',\\n 'facet.field': 'course_subject',\\n 'facet.mincount': '1',\\n 'facet.sort': 'index', # Sort alphabetically\\n 'rows': '0', # we don't need any actual document\\n }\\n if all:\\n q['q'] = '*:*'\\n else:\\n q['q'] = 'NOT presentation_start:[* TO NOW]'\\n results = searcher.search(q, start=0, count=1000) # Do not paginate\\n subjects = subjects_facet_to_subjects_domain(results)\\n return subjects\",\n \"def discretize(self,dt):\\n res = self.discretize_state(dt)\\n n = len(res.milestones[0])//2\\n return Trajectory(res.times,[m[:n] for m in res.milestones])\",\n \"def get_timepoints(self):\\n return list(sorted(self.mdvtc.keys()))\",\n \"def test_get_full_topic_courses(self):\\r\\n course_id = None # Change me!!\\r\\n topic_id = None # Change me!!\\r\\n\\r\\n r = self.client.get_full_topic_courses(topic_id, course_id)\",\n \"def see_teaching_courses(self, username: str, token: str) -> List[Dict[str, object]]:\\n\\n # Validate user first\\n if not self.validate(username=username, token=token, check_privilege='instructor'):\\n raise RuntimeError(\\\"User not verified!\\\")\\n\\n # Get UID from user's username\\n uid = self.get_uid(username=username)\\n\\n # Query database for courses instructed by a user with this UID\\n cursor = self._db_connection.cursor()\\n cursor.execute(\\n '''\\n SELECT \\n course_id,\\n course_abbreviation,\\n course_name, \\n time,\\n seats \\n FROM \\n courses\\n WHERE \\n instructor_id = ?\\n ;\\n ''', (uid,))\\n\\n db_results = cursor.fetchall()\\n\\n if db_results is None:\\n print(\\\"No associated courses found!\\\")\\n return []\\n\\n # Build information dicts for every course this user is instructing\\n courses = []\\n for result in db_results:\\n # Get the number of students enrolled in this course already\\n cursor.execute('''SELECT COUNT(*) FROM enrollment_records WHERE course_id = ?;''', (result[0],))\\n students_enrolled = cursor.fetchone()[0]\\n if students_enrolled is None:\\n students_enrolled = 0\\n\\n # Build a course dict from the data\\n courses.append({\\n \\\"course_abbreviation\\\": result[1],\\n \\\"course_name\\\": result[2],\\n \\\"time\\\": result[3],\\n \\\"students_enrolled\\\": students_enrolled,\\n \\\"capacity\\\": result[4],\\n })\\n\\n return courses\",\n \"def pc_work_time_total(self):\\n return _TestA_swig.cleanslate_sptr_pc_work_time_total(self)\",\n \"def test_has_course(self):\\r\\n check_has_course_method(\\r\\n XMLModuleStore(DATA_DIR, course_dirs=['toy', 'simple']),\\r\\n SlashSeparatedCourseKey('edX', 'toy', '2012_Fall'),\\r\\n locator_key_fields=SlashSeparatedCourseKey.KEY_FIELDS\\r\\n )\",\n \"def satisfying_courses(self):\\n return (\\n Course.objects.all()\\n .exclude(id__in=self.overrides.all())\\n .filter(\\n Q(department__in=self.departments.all(), semester=self.semester)\\n | Q(id__in=self.courses.all())\\n )\\n )\",\n \"def graph_course(self):\\n group = self.__data[\\\"filted_general_groupby\\\"]\\n graph = {}\\n if self.analysis[\\\"courses\\\"] is None:\\n self.courses_list()\\n\\n # inicializa o dicionario que vai guardar o grafico\\n for course in self.analysis[\\\"courses\\\"].index:\\n graph[course] = []\\n\\n for i in range(18):\\n min_v = i * 5\\n max_v = min_v + 4.99\\n self.__calc_graph_mean(group, min_v, max_v, graph)\\n\\n min_v = 95\\n max_v = 100\\n self.__calc_graph_mean(group, min_v, max_v, graph)\\n\\n self.analysis[\\\"graph_course\\\"] = graph\",\n \"def test_xblockcompletion_no_data_course(self):\\n from lms.djangoapps.courseware.models import StudentModule\\n data = {\\n 'format':'all'\\n }\\n response = self.client_instructor.get(reverse('xblockcompletion-data:data'), data)\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(json.loads(response._container[0].decode()), {'error': 'Falta parametro course o parametro incorrecto'})\",\n \"def course_lineup(self):\\n return None\",\n \"def tcvs(self): \\n return self._link_reg.tcvs\",\n \"def get_course(self):\\r\\n return self.descriptor.runtime.modulestore.get_course(self.course_id)\",\n \"def get_sorted_courses(self, include_unscheduled=False) -> List[Course]:\\n return sorted(\\n filter(\\n lambda c: c.time is not None or include_unscheduled, self.get_courses()\\n ),\\n key=lambda c: (0, 0) if not c.time else (c.weekday(), c.time.start),\\n )\",\n \"def year_demand_rule(_m, y):\\r\\n\\r\\n return sum(m.SCENARIO_DEMAND[y, s] for s in m.S)\",\n \"def get_course_ids(self):\\n if not self.is_course_based_activity():\\n raise IllegalState()\\n else:\\n raise Unimplemented()\",\n \"def test_course_listing_performance(self):\\r\\n # create and log in a non-staff user\\r\\n self.user = UserFactory()\\r\\n request = self.factory.get('/course')\\r\\n request.user = self.user\\r\\n self.client.login(username=self.user.username, password='test')\\r\\n\\r\\n # create list of random course numbers which will be accessible to the user\\r\\n user_course_ids = random.sample(range(TOTAL_COURSES_COUNT), USER_COURSES_COUNT)\\r\\n\\r\\n # create courses and assign those to the user which have their number in user_course_ids\\r\\n for number in range(TOTAL_COURSES_COUNT):\\r\\n org = 'Org{0}'.format(number)\\r\\n course = 'Course{0}'.format(number)\\r\\n run = 'Run{0}'.format(number)\\r\\n course_location = SlashSeparatedCourseKey(org, course, run)\\r\\n if number in user_course_ids:\\r\\n self._create_course_with_access_groups(course_location, self.user)\\r\\n else:\\r\\n self._create_course_with_access_groups(course_location)\\r\\n\\r\\n # time the get courses by iterating through all courses\\r\\n with Timer() as iteration_over_courses_time_1:\\r\\n courses_list = _accessible_courses_list(request)\\r\\n self.assertEqual(len(courses_list), USER_COURSES_COUNT)\\r\\n\\r\\n # time again the get courses by iterating through all courses\\r\\n with Timer() as iteration_over_courses_time_2:\\r\\n courses_list = _accessible_courses_list(request)\\r\\n self.assertEqual(len(courses_list), USER_COURSES_COUNT)\\r\\n\\r\\n # time the get courses by reversing django groups\\r\\n with Timer() as iteration_over_groups_time_1:\\r\\n courses_list = _accessible_courses_list_from_groups(request)\\r\\n self.assertEqual(len(courses_list), USER_COURSES_COUNT)\\r\\n\\r\\n # time again the get courses by reversing django groups\\r\\n with Timer() as iteration_over_groups_time_2:\\r\\n courses_list = _accessible_courses_list_from_groups(request)\\r\\n self.assertEqual(len(courses_list), USER_COURSES_COUNT)\\r\\n\\r\\n # test that the time taken by getting courses through reversing django groups is lower then the time\\r\\n # taken by traversing through all courses (if accessible courses are relatively small)\\r\\n self.assertGreaterEqual(iteration_over_courses_time_1.elapsed, iteration_over_groups_time_1.elapsed)\\r\\n self.assertGreaterEqual(iteration_over_courses_time_2.elapsed, iteration_over_groups_time_2.elapsed)\",\n \"def get_course_table(self, table):\\n json_result = {}\\n row_list = table.xpath('.//table[@id = \\\"s_course\\\"]/tr[position() > 1]')\\n for row in row_list:\\n session = row.xpath('./td[1]/text()')\\n course_full_code_list = row.xpath('.//a[starts-with(@href, \\\"javascript:course_popup\\\")]/text()')\\n course_name_list = row.xpath('.//font[@style = \\\"font-size:7pt;\\\"]/text()')\\n course_list = []\\n if len(course_full_code_list) != len(course_name_list):\\n # year course design project would be count twice\\n if (\\\"Design Project\\\" == course_name_list[0]) & \\\\\\n (len(course_full_code_list) + 1 == len(course_name_list)):\\n course_name_list = course_name_list[1:]\\n else:\\n raise ProfileException(\\n \\\"Error: unmatched lists. course code list:\\\",\\n course_full_code_list, \\\"\\\\n course name list:\\\", course_name_list)\\n for i, full_code in enumerate(course_full_code_list):\\n if re.match(re.compile('\\\\w{3}\\\\d{3}[YH]1\\\\s+[SFY]'), full_code) is None:\\n raise ProfileException(\\\"Illegal course code!:\\\" + full_code)\\n course_list.append({\\n \\\"courseName\\\": course_name_list[i],\\n \\\"courseCode\\\": full_code[0:6],\\n \\\"courseTime\\\": full_code[-1],\\n \\\"courseLength\\\": full_code[6:8]\\n })\\n # there is a empty session\\n if session:\\n json_result.update({session[0]: course_list})\\n if json_result:\\n return json_result\\n else:\\n raise ProfileException(\\\"Failed to get course_table table(row list is empty)\\\")\",\n \"def get_all_teacher_courses(cls, user):\\n member_record = CourseMember.objects.filter(user=user)\\n member_teacher = member_record.filter(Q(type = 0) | Q(type = 1) | Q(type = 2))\\n teacher_list = []\\n\\n for member in member_teacher:\\n if member.course.pk not in teacher_list:\\n teacher_list.append(member.course.pk)\\n\\n return teacher_list\",\n \"def course(self):\\n return self.section.course\",\n \"def test_xml_get_courses(self):\\r\\n self.initdb('direct')\\r\\n courses = self.store.modulestores['xml'].get_courses()\\r\\n self.assertEqual(len(courses), 2)\\r\\n course_ids = [course.id for course in courses]\\r\\n self.assertIn(self.course_locations[self.XML_COURSEID1].course_key, course_ids)\\r\\n self.assertIn(self.course_locations[self.XML_COURSEID2].course_key, course_ids)\\r\\n # this course is in the directory from which we loaded courses but not in the map\\r\\n self.assertNotIn(\\\"edX/toy/TT_2012_Fall\\\", course_ids)\",\n \"def get_cumulative_model(self):\\n cm = None\\n for ac in self.ac:\\n if ac[0] is None:\\n continue\\n m = self.get_model(last=False, a=ac[0], c=ac[1])\\n cm = m if cm is None else cm+m\\n return cm\",\n \"def get_course(self):\\n is_draft = self.direct_course.extended_object.publisher_is_draft\\n ancestor_nodes = self.direct_course.extended_object.node.get_ancestors()\\n return Course.objects.filter(\\n # Joining on `cms_pages` generate duplicates for courses that are under a parent page\\n # when this page exists both in draft and public versions. We need to exclude the\\n # parent public page to avoid this duplication\\n Q(\\n extended_object__node__cms_pages__publisher_is_draft=is_draft\\n ) # course has a parent\\n | Q(extended_object__node__isnull=True), # course has no parent\\n # Target courses that are ancestors of the course related to the course run\\n Q(id=self.direct_course_id) | Q(extended_object__node__in=ancestor_nodes),\\n # Exclude snapshots\\n extended_object__node__parent__cms_pages__course__isnull=True, # exclude snapshots\\n # Get the course in the same version as the course run\\n extended_object__publisher_is_draft=is_draft,\\n ).distinct()[0]\",\n \"def get_courses_html():\\r\\n r = requests.get(URL_CS_ALL_REQ)\\r\\n if r.status_code == 200:\\r\\n return r.text\\r\\n else:\\r\\n return None\",\n \"def discretize(self,dt):\\n self._skip_deriv = True\\n res = self.discretize_state(dt)\\n self._skip_deriv = False\\n n = self.geodesic.extrinsicDimension()\\n return GeodesicTrajectory(self.geodesic,res.times,[m[:n] for m in res.milestones])\",\n \"def test_import(self):\\r\\n descriptor = self.get_dummy_course(START)\",\n \"def extract_ace_data(event, start, stop):\\n#\\n#--- year of starting time\\n#\\n atemp = re.split(':', start)\\n syear = int(float(atemp[0]))\\n atemp = re.split(':', stop)\\n eyear = int(float(atemp[0]))\\n#\\n#--- convert time in Chandra Time\\n#\\n lstart = start\\n start = time.strftime('%Y:%j:%H:%M:00', time.strptime(start, '%Y:%m:%d:%H:%M'))\\n stop = time.strftime('%Y:%j:%H:%M:00', time.strptime(stop, '%Y:%m:%d:%H:%M'))\\n start = int(Chandra.Time.DateTime(start).secs)\\n stop = int(Chandra.Time.DateTime(stop).secs)\\n#\\n#--- set to data collecting period\\n#\\n pstart = start - 2 * aday\\n period = int((stop - start) / (5 * aday)) + 1\\n pstop = start + 5 * period * aday\\n\\n data = []\\n for year in range(syear, eyear+1):\\n ifile = data_dir + 'rad_data' + str(syear)\\n tdata = mcf.read_data_file(ifile)\\n data = data + tdata\\n\\n hline = 'Science Run Interruption: ' + lstart + '\\\\n'\\n hline = hline + 'dofy electron38 electron175 protont47 proton112 '\\n hline = hline + 'proton310 proton761 proton1060 aniso\\\\n'\\n hline = hline + '-' * 100\\n\\n for ent in data:\\n atemp = re.split('\\\\s+', ent)\\n if atemp[0].isdigit():\\n ltime = atemp[0] + ':' + atemp[1] + ':' + atemp[2] + ':' + atemp[3]\\n ltime = time.strftime('%Y:%j:%H:%M:00', time.strptime(ltime, '%Y:%m:%d:%H%M'))\\n stime = int(Chandra.Time.DateTime(ltime).secs)\\n if (stime >= pstart) and (stime < pstop):\\n hline = hline + '%3.4f\\\\t' % chandara_time_to_yday(stime, syear) \\n hline = hline + atemp[7] + '\\\\t' + atemp[8] + '\\\\t'\\n hline = hline + atemp[10] + '\\\\t' + atemp[11] + '\\\\t'\\n hline = hline + atemp[12] + '\\\\t' + atemp[13] + '\\\\t'\\n hline = hline + atemp[14] + '\\\\t' + atemp[15] + '\\\\n'\\n\\n#\\n#--- print out the data\\n#\\n ofile = wdata_dir + event + '_dat.txt'\\n\\n with open(ofile, 'w') as fo:\\n fo.write(hline)\",\n \"def _find_memberless_constituencies(self):\\n constituencies = Constituency.objects.filter(\\n end=None, # Constituency currently exists/is not historical\\n mp=None,\\n )\\n\\n self.stdout('Constituencies with missing MP:')\\n for constituency in constituencies:\\n self.stdout(f'[{constituency.parliamentdotuk}] {constituency.name} {constituency.start}')\",\n \"def trial_wtd(trial, omit_missing_frames=True):\\n x = np.arange(len(trial.HMM_MLE))/60\\n y = (trial.HMM_MLE == 0)\\n if omit_missing_frames:\\n x = x[trial.HMM_MLE >= 0]\\n y = y[trial.HMM_MLE >= 0]\\n return linear_regression_with_CIs(x/60, y, return_CIs=False)\",\n \"def get_course(self, _):\\r\\n courses = self.modulestore.get_courses()\\r\\n return courses[0]\",\n \"def threat(year, clock):\\n # find latest adjustment preceding or equal to the given year\\n index = -1\\n while clock[index][0] > year:\\n index -= 1\\n # return time set at latest adjustment\\n return clock[index][1]\",\n \"def get_detailed_ddct_data(self, assay):\\n df = self.ddct.query(\\\"Assay == '{}'\\\".format(assay)).reset_index(drop=True)\\n return pandas.pivot_table(df, values=0, columns='time', index=['cell_line', 'treatment', 'replicate'])\",\n \"def get_units_with_due_date(course):\\r\\n units = []\\r\\n\\r\\n def visit(node):\\r\\n \\\"\\\"\\\"\\r\\n Visit a node. Checks to see if node has a due date and appends to\\r\\n `units` if it does. Otherwise recurses into children to search for\\r\\n nodes with due dates.\\r\\n \\\"\\\"\\\"\\r\\n if getattr(node, 'due', None):\\r\\n units.append(node)\\r\\n else:\\r\\n for child in node.get_children():\\r\\n visit(child)\\r\\n visit(course)\\r\\n #units.sort(key=_title_or_url)\\r\\n return units\",\n \"def get_past_ec(self, timestep):\\n df = DataFrame(list(self.ec_db.find({'time': timestep})))\\n df.index = df.ec\\n return df\",\n \"def requested_courses(self, user_id: str) -> np.ndarray:\\n self.retrieve_leads()\\n\\n return self.leads_df[self.leads_df['user_id'] == user_id]['course_id'].values\",\n \"def test_get_course_list(self):\\r\\n request = self.factory.get('/course/')\\r\\n request.user = self.user\\r\\n\\r\\n course_location = SlashSeparatedCourseKey('Org1', 'Course1', 'Run1')\\r\\n self._create_course_with_access_groups(course_location, self.user)\\r\\n\\r\\n # get courses through iterating all courses\\r\\n courses_list = _accessible_courses_list(request)\\r\\n self.assertEqual(len(courses_list), 1)\\r\\n\\r\\n # get courses by reversing group name formats\\r\\n courses_list_by_groups = _accessible_courses_list_from_groups(request)\\r\\n self.assertEqual(len(courses_list_by_groups), 1)\\r\\n # check both course lists have same courses\\r\\n self.assertEqual(courses_list, courses_list_by_groups)\",\n \"def test_returns_concurrent_meeting_time(self):\\n result = meeting_planner([[10, 50], [60, 120], [140, 210]], [[0, 15], [60, 70]], 8)\\n self.assertEqual(result, [60, 68])\",\n \"def get_add_years(course):\\n # Add 1 year if verification happens during fall, 0 if during spring.\\n add_years = 1 if timezone.now().month >= 7 else 0\\n\\n if course['id'] == GROUP_IDENTIFIERS['PROSJEKT1']:\\n add_years += 1\\n elif course['id'] == GROUP_IDENTIFIERS['ALGDAT']:\\n add_years += 1\\n elif course['id'] == GROUP_IDENTIFIERS['PROSJEKT2']:\\n add_years += 3\\n\\n return min(3, add_years)\",\n \"def get_time_step_values(self):\\n return OcTreeReader.get_time_step_values(self)\",\n \"def get_timesteps(cur):\\n info = cur.execute('SELECT initialyear, initialmonth, '\\n 'duration FROM info').fetchone()\\n init_year = info['initialyear']\\n init_month = info['initialmonth']\\n duration = info['duration']\\n timestep = np.linspace(0, duration - 1, num=duration)\\n\\n return init_year, init_month, duration, timestep\",\n \"def pc_work_time_avg(self):\\n return _TestA_swig.cleanslate_sptr_pc_work_time_avg(self)\",\n \"def get_total_course_completions_for_time_period(site, end_date, **_kwargs):\\n return total_site_certificates_as_of_date(site=site, date_for=end_date)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6250547","0.62290126","0.61140645","0.59820795","0.59133375","0.5577022","0.54320115","0.5422249","0.5395153","0.5357361","0.53467005","0.5322102","0.53120166","0.5310064","0.526714","0.5255139","0.5216506","0.51582277","0.5101761","0.5069965","0.5056666","0.50391835","0.5018053","0.49922186","0.4989972","0.4987744","0.4969875","0.49690393","0.49354365","0.4931215","0.49288562","0.49165285","0.48890996","0.4882583","0.48801106","0.48644143","0.48637798","0.4860317","0.48402077","0.48369336","0.482467","0.482381","0.48215887","0.4814986","0.4814986","0.4814986","0.48083374","0.48040998","0.47930378","0.4790103","0.47898412","0.47630006","0.47622073","0.47535685","0.47508502","0.47462016","0.47358337","0.47314256","0.47267795","0.472257","0.47181863","0.47151536","0.47093612","0.47045544","0.46998054","0.46974507","0.4690981","0.4690363","0.46894935","0.468918","0.4688388","0.46862486","0.46775365","0.46772733","0.46707413","0.46644467","0.46636534","0.46599263","0.465945","0.46573576","0.46569383","0.46495014","0.46396706","0.46370286","0.4636537","0.46310407","0.46304345","0.46302992","0.46282443","0.46272653","0.46195492","0.46192774","0.46189216","0.46154383","0.4611989","0.4610089","0.46091056","0.4604883","0.46021524","0.45996934"],"string":"[\n \"0.6250547\",\n \"0.62290126\",\n \"0.61140645\",\n \"0.59820795\",\n \"0.59133375\",\n \"0.5577022\",\n \"0.54320115\",\n \"0.5422249\",\n \"0.5395153\",\n \"0.5357361\",\n \"0.53467005\",\n \"0.5322102\",\n \"0.53120166\",\n \"0.5310064\",\n \"0.526714\",\n \"0.5255139\",\n \"0.5216506\",\n \"0.51582277\",\n \"0.5101761\",\n \"0.5069965\",\n \"0.5056666\",\n \"0.50391835\",\n \"0.5018053\",\n \"0.49922186\",\n \"0.4989972\",\n \"0.4987744\",\n \"0.4969875\",\n \"0.49690393\",\n \"0.49354365\",\n \"0.4931215\",\n \"0.49288562\",\n \"0.49165285\",\n \"0.48890996\",\n \"0.4882583\",\n \"0.48801106\",\n \"0.48644143\",\n \"0.48637798\",\n \"0.4860317\",\n \"0.48402077\",\n \"0.48369336\",\n \"0.482467\",\n \"0.482381\",\n \"0.48215887\",\n \"0.4814986\",\n \"0.4814986\",\n \"0.4814986\",\n \"0.48083374\",\n \"0.48040998\",\n \"0.47930378\",\n \"0.4790103\",\n \"0.47898412\",\n \"0.47630006\",\n \"0.47622073\",\n \"0.47535685\",\n \"0.47508502\",\n \"0.47462016\",\n \"0.47358337\",\n \"0.47314256\",\n \"0.47267795\",\n \"0.472257\",\n \"0.47181863\",\n \"0.47151536\",\n \"0.47093612\",\n \"0.47045544\",\n \"0.46998054\",\n \"0.46974507\",\n \"0.4690981\",\n \"0.4690363\",\n \"0.46894935\",\n \"0.468918\",\n \"0.4688388\",\n \"0.46862486\",\n \"0.46775365\",\n \"0.46772733\",\n \"0.46707413\",\n \"0.46644467\",\n \"0.46636534\",\n \"0.46599263\",\n \"0.465945\",\n \"0.46573576\",\n \"0.46569383\",\n \"0.46495014\",\n \"0.46396706\",\n \"0.46370286\",\n \"0.4636537\",\n \"0.46310407\",\n \"0.46304345\",\n \"0.46302992\",\n \"0.46282443\",\n \"0.46272653\",\n \"0.46195492\",\n \"0.46192774\",\n \"0.46189216\",\n \"0.46154383\",\n \"0.4611989\",\n \"0.4610089\",\n \"0.46091056\",\n \"0.4604883\",\n \"0.46021524\",\n \"0.45996934\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4884956"},"document_rank":{"kind":"string","value":"33"}}},{"rowIdx":12891,"cells":{"query":{"kind":"string","value":"verify integrity of user input"},"document":{"kind":"string","value":"def do_checks(self):\n # ## get valid experiment variables\n all_subexperiments = [1, 2, 3]\n all_plates = list(range(1, 19))\n all_cell_ids = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']\n all_samples = list(self.experiment.design['Sample'])\n all_genes = self.experiment.subexperiments[1].plates[1].samples[all_samples[0]].genes\n all_replicates = list(range(1, 7))\n all_time = [0.5, 1.0, 2.0, 3.0, 4.0, 8.0, 12.0, 24.0, 48.0, 72.0, 96.0]\n\n if self.time is None:\n if self.treatment is 'Baseline':\n self.time = [0.0, 96.0]\n else:\n self.time = all_time\n\n if self.cell_id is None:\n self.cell_id = all_cell_ids\n\n if self.gene is None:\n self.gene = all_genes\n\n if self.replicate is None:\n self.replicate = all_replicates\n\n if self.treatment is None:\n raise ValueError('treatment cannot be None. Specify one of \"TGFb\", \"Control\", \"Baseline\"')\n\n if not isinstance(self.treatment, str):\n raise ValueError('treatment must be a string. Got \"{}\" a \"{}\"'.format(\n self.treatment, type(self.treatment)\n ))\n\n if not isinstance(self.normed, bool):\n raise ValueError('normed argument should be boolean. Got \"{}\"'.format(\n type(self.normed)\n ))\n\n if not isinstance(self.time, list):\n self.time = [self.time]\n\n for time_point in self.time:\n if time_point not in sorted(list(set(self.data.columns.get_level_values(1)))):\n raise ValueError('\"{}\" is invalid time point. Valid time '\n 'points are: {}'.format(\n time_point, list(self.data.columns))\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 check_validity(self):","def isInputValid(self, input):\r\n pass","def validate():","def validate_input(self, *args):\n return","def verify():","def validate_user_input(user_input):\n responses = ['t', 'r', 'q']\n return user_input in responses","def test_valid_user_input(self):\n\n test_name = sys._getframe().f_code.co_name\n\n log.info(\"###### TEST EXECUTION STARTED :: \" + test_name + \" ######\")\n\n user_input = data_reader.get_data(test_name, \"Text_Message\")\n\n with allure.step(\"Verify User Input\"):\n result = self.main_page.verify_valid_user_input(user_input)\n self.exe_status.mark_final(test_step=test_name, result=result)","def check():","def _check_validity(self):\n pass","def validate_input():\n pass_length = None\n account_name = None\n method = None\n in_value = None\n parser = ArgumentParser()\n parser.add_argument(\"-l\", \"--length\",\n type=int,\n help=\"length of password\")\n\n parser.add_argument(\"-a\", \"--account\",\n help=\"account or site name\")\n\n parser.add_argument(\"-m\", \"--method\",\n help=\"method to take [S|C|R|U|D]\")\n\n parser.add_argument(\"-v\", \"--value\",\n help=\"Do not generate, store this value\")\n\n args = parser.parse_args()\n if args.length:\n pass_length = int(args.length)\n\n if args.account:\n account_name = str(args.account)\n\n if args.method:\n method = str.upper(args.method)\n\n if args.value:\n in_value = str(args.value)\n\n return (pass_length, account_name, method, in_value)","def verify(self):\n data = [\"rfc\", \"tel\", \"email\", \"name\", \"use\"]\n state = False\n for item in data:\n if getattr(self, item + \"Input\").text() != \"\":\n state = True\n else:\n return False\n return state","def _check_inputs(self):\n\n self._check_resident_prefs()\n self._check_hospital_prefs()","def _check_for_incomplete_input(self):\n pass","def are_input_correct(self):\n\n\t\tname_user = self.check_this_input(self.entrada_usr, 100)\n\t\tpass_user = self.check_this_input(self.entrada_pwd, 72)\n\n\t\treturn name_user,pass_user","def validate_input(self):\n if (self.options.mexURL and self.options.token): #run module through engine service\n return True\n\n if (self.options.user and self.options.pwd and self.options.root): #run module locally (note: to test module)\n return True\n\n log.debug('Dream3D: Insufficient options or arguments to start this module')\n return False","def test_input2(self):\n in1 =\"aple\"\n result = options.checkw(in1)\n self.assertEqual(result,False)","def test_validate_input_rejection(self):\n with nose.assert_raises(exceptions.RejectionError):\n self.dtm1.validate_input('000011')","def validateInput(self): \n if (self.options.mexURL and self.options.token): #run module through engine service\n return True\n \n if (self.options.user and self.options.pwd and self.options.root): #run module locally (note: to test module)\n return True\n \n log.debug('Botanicam: Insufficient options or arguments to start this module')\n return False","def test_validate_input_good_input(self):\r\n _validate_input(self.dist_matrix_header, self.dist_matrix,\r\n self.mapping_header, self.mapping, \"Treatment\")","def main():\n user_input = user_input_state()\n check_user_input(user_input)","def __checkInput(self, var):\n try:\n int(var)\n\n except:\n return False\n\n else:\n return True","def validate(info):\n\n\tif info == \"\": \n\t\treturn False\n\telse:\n\t\tif len(info) < 5 or len(info) > 32:\n\t\t\treturn False\n\t\telse:\n\t\t\treturn True","def checkUserInput(self):\n prm = []\n err = \"\"\n guess = self.text.text()\n items = str(guess).split(',')\n if len(items) != 2:\n err = \"Two parameters must be given\"\n else:\n for i in range(0, len(items)):\n val = items[i].strip()\n if not isNumber(val):\n err = \"Parameter {0} is not numeric\".format(i + 1)\n break\n if float(val) < 0.0:\n err = \"Parameter {0} is negative\".format(i + 1)\n break\n val = float(val)\n if i == 0 and val > self.yspan:\n err = \"minHeight is too large\"\n break\n if i == 1:\n if val < self.xspan/self.npt or val > self.xspan/2:\n err = \"minWidth is too large\"\n break\n prm.append(val)\n if err:\n errmsg = \"Incorrect input:\\n{0}\".format(err)\n QtWidgets.QMessageBox.warning(self, self.title, errmsg)\n return False\n\n # Store parameters values in global variables for the next call\n global lastfilename, lastmph, lastmpw\n lastfilename = self.pltw.filename\n self.mph = lastmph = prm[0]\n self.mpw = lastmpw = prm[1]\n return True","def _verify_arguments(self):\n # if self.options.action == \"create\":\n # if self.options.encrypt_payload and not self.options.payload_secret:\n # self.parser.error('A secret must be supplied with --payload-secret option when the --encrypt-payload option is in use.')\n pass","def check_all_user_inputs_valid(self):\n self.check_RNN_layers_valid()\n self.check_activations_valid()\n self.check_embedding_dimensions_valid()\n self.check_initialiser_valid()\n self.check_y_range_values_valid()\n self.check_return_final_seq_only_valid()","def input_check(self):\n\n if self.species == 'He': assert self.line_model == 'voigt'\n n_upper_range, e_dens_range, temp_range, b_field_range = get_param_ranges(self.line_model)\n\n if np.isnan(n_upper_range).sum() <= 1:\n assert (self.n_upper in range(n_upper_range[0], n_upper_range[1]))\n if np.isnan(e_dens_range).sum() <= 1:\n assert (e_dens_range[0] <= self.e_dens <= e_dens_range[1])\n if np.isnan(temp_range).sum() <= 1:\n assert (temp_range[0] <= self.temp <= temp_range[1])\n if np.isnan(b_field_range).sum() <= 1:\n assert (b_field_range[0] <= self.b_field <= b_field_range[1])","def input_validation(self, prompt):\r\n\r\n while True:\r\n try:\r\n x, y = map(int, input(prompt).split())\r\n except ValueError: # when there is less than or more than 2 input values\r\n print('Invalid input try again.')\r\n continue\r\n if (x != self.selected[0]) or (y != self.selected[1]): # different from first choice\r\n if (0 <= x <= 3) and (0 <= y <= 12): # Valid input\r\n if not ([x, y] in self.bin): # Check if this card is still there or not\r\n break\r\n else:\r\n print('This card has already been taken.')\r\n continue\r\n else: # invalid input\r\n print('Row and column should be from 0 to 3 and 1 to 12 respectively.')\r\n continue\r\n else:\r\n print('Choose a card different from your first choice')\r\n continue\r\n return x, y","def check(self):\n view_keys(self.d)\n paso1=input('Do you want to change any parameter?(y/n)\\n')\n while paso1[0] == 'y':\n key=input('Which one?\\n')\n if key not in self.d:\n paso2=input(\"This parameter is not in the dictionary.\\\nDo you want to include it?(y/n)\\n\")\n if paso2[0]=='y':\n value=input('value(s) of '+key+'?= ')\n self.d[key]=tuple(split(replace(value,',',' ')))\n else:continue\n else:\n value=input('New value(s) of '+key+'?= ')\n self.d[key]=tuple(split(replace(value,',',' ')))\n view_keys(self.d)\n paso1=input('Anything else?(y/n)\\n')","def verify_prompt(prompt: str, expected: str = \"y\"):\n input_ = input(prompt)\n if input_ != expected:\n raise ValidationError(f\"Expected {expected}, got {input_}\")","def __validate():\n # TODO: implement","def validate(self):\n return (self.check_input_digits_count()\n and self.check_if_input_is_int()\n and self.check_if_input_digits_are_unique())","def check_vulnerability(self):\n\t\tpass","def validate_input(user_input: str) -> bool:\n\n if not user_input.islower():\n return False\n\n if user_input.endswith(\"yeet\"):\n return False\n \n if \"q\" or \"Q\" in user_input: # Check if q is a letter\n return False\n \n return True # If none of the conditions above are met","def check(self) -> None:","def validate_action(self, message=\"This action may delete data from the database. This action cannot be undone.\\nDo you wish to continue? (Y/N): \"):\n \n while True:\n print('\\n\\n')\n inp = input(message)\n \n if (inp.upper() == 'Y'):\n return True\n elif (inp.upper() == 'N'):\n return False\n \n print(\"Invalid input. Try again\")","def check_input(saved_input):\n if saved_input.lower() == \"!yes\":\n return True\n if saved_input.lower() == \"!no\":\n return False","def _validate_input(self):\n self.data.validate()\n self.meta_hybridizer.validate_input()","def first_is_valid(command_from_user):\n arguement_entered_user = command_from_user[0]\n if arguement_entered_user == 'list':\n return True\n \n elif arguement_entered_user == 'clashes':\n return True\n \n else:\n return False","def test_validate_input_valid(self):\n final_config = self.dtm1.validate_input('00001111')\n nose.assert_equal(final_config[0], 'q4')\n nose.assert_equal(str(final_config[1]), 'TMTape(\\'xxxxyyyy.\\')')","def validate(self):","def validate(self):","def question_new_validate():","def test_input1(self):\n in1 =\"elephant\"\n result = options.check(in1)\n self.assertEqual(result,True)","def checkInput(userInput):\n if userInput == 'exit':\n return 0\n return 1","def validate(self):\r\n return 1","def validate(self):\r\n return 1","def validate(self):\r\n return 1","def validate(self):\r\n return 1","def validate(self):\r\n return 1","def __check_validation(input_string):\n if not input_string:\n raise NullInputException(\"Input string should be not empty\")\n if type(input_string) != str:\n raise NonStringInputException(\"Input value should be a string\")\n if len(input_string) >= 200:\n raise TooLongInputException(\"Input string should be less than 200 characters\")\n for i in input_string:\n if not i.isalpha():\n raise NonStringInputException(\"All input value characters should be an alpha\")","def validate(ob):","def test_check_validity(\n student_names, project_names, supervisor_names, capacities, seed, clean\n):\n\n *_, game = make_game(\n student_names, project_names, supervisor_names, capacities, seed, clean\n )\n\n game.solve()\n assert game.check_validity()","async def validate(self, ctx: Context, argument: str) -> bool:\n return True","def violated(self) -> bool:\n ...","def validate(self):\n return 1","def valid_args(args):\n is_valid = True\n if not args.ts_url or not args.username or not args.password or not args.from_user or not args.to_user:\n eprint(\"Missing required parameters.\")\n is_valid = False\n\n return is_valid","def _validate(self, *_):\n provider = self.provider_entry.get_text()\n username = self.account_name_entry.get_text()\n token = \"\".join(self.token_entry.get_text().split())\n\n if not username:\n self.account_name_entry.get_style_context().add_class(\"error\")\n valid_name = False\n else:\n self.account_name_entry.get_style_context().remove_class(\"error\")\n valid_name = True\n\n if not provider:\n self.provider_combobox.get_style_context().add_class(\"error\")\n valid_provider = False\n else:\n self.provider_combobox.get_style_context().remove_class(\"error\")\n valid_provider = True\n\n if (not token or not OTP.is_valid(token)) and not self.props.is_edit:\n self.token_entry.get_style_context().add_class(\"error\")\n valid_token = False\n else:\n self.token_entry.get_style_context().remove_class(\"error\")\n valid_token = True\n\n self.emit(\"changed\", all([valid_name, valid_provider, valid_token]))","def valid(self):\n pass","def validate_command_line_input(args):\n valid = False\n if 0 < len(args) <= 4:\n valid = True\n for arg in args:\n if int(arg) > 4:\n valid = False\n break\n else:\n pass\n if valid:\n CRUDStarter.load_operations(args)\n pass\n else:\n CRUDStarter.logger.info(\"Argument maximum acceptable value is 4\")\n else:\n CRUDStarter.logger.info(\"at least One at most Four argument(s) required\")","def _is_valid(self):\n self._is_allows_valid()\n self._is_denies_valid()","def verify(self):","def validate(self):\n stguess = self.text.toPlainText()\n if not self.pkfitdlg.checkUserInput(stguess):\n return\n self.stguess = stguess\n self.accept()","def valid_response(prompt, *valid):\r\n ans = console_input(prompt).lower()\r\n\r\n if ans in valid:\r\n return True\r\n elif ans == '':\r\n return None\r\n\r\n return False","def wizard_input_verification(form):\n # Note,that key must start with line_..., other options are ignored, to allow DNF option to work\n lines = [value for key, value in form.items() if key.startswith(\"line\")]\n # if the entered lines are unique, they will have the same value\n if len(lines) != len(set(lines)):\n return False\n else:\n return True","def check(self, input, node):\n assert False # Must be redefined","def sanity_check(self):\n return True","def check_input(the_user_entry):\n try:\n for z in range(length_of_bad_input):\n if bad_input[z] == the_user_entry:\n messagebox.showwarning(title=\"Invalid input!\",\n message=\"The following characters are forbidden:\\n\"\n \"~`!@#$%^&*()_-+={[}]|\\\\:;\\\"\\'<,>.?/1234567890\")\n clear_box()\n raise ValueError\n except ValueError:\n print(\"The user entered an invalid character in the entry box\\n\"\n \"potentially one of the following:\\n\"\n \"~`!@#$%^&*()_-+={[}]|\\\\:;\\\"\\'<,>.?/1234567890\")","def validate(self):\n try:\n self.values.clear()\n self.values.append(int(self.e1.get()))\n except ValueError:\n messagebox.showwarning(\n \"Bad input\",\n \"Illegal values, please try again.\")\n return False\n\n return True","def __check_inputs__(self):\n # | - __check_inputs__\n # #####################################################################\n stop_mode = self.stop_mode\n stop_num_generations = self.stop_num_generations\n # #####################################################################\n\n if stop_mode == \"num_generations\":\n mess_i = \"stop_mode='num_generations', \\\n Must pass int to 'stop_num_generations'\"\n assert type(stop_num_generations) == type(1), mess_i\n #__|","def checkCorrectness(self):\n self.checkNeededParams()\n if self.getParam(\"help\") == True:\n return False\n return True","def check_input(para_dic, parser):\n # for prokarya\n if para_dic['kingdom'] in [\"prokarya\", \"both\"]:\n if para_dic[\"fasta_prok\"] is None:\n parser.error(\"\"\"prokarya requires fasta file to be specified using\n fasta_prok in config file\"\"\")\n else:\n if os.path.exists(para_dic[\"fasta_prok\"]) is False:\n parser.error(\"\"\"reference genome doesnt exist\"\"\")\n if para_dic[\"gff_prok\"] is None:\n parser.error(\"\"\"prokarya requires gff file to be specified using\n gff_prok in config file\"\"\")\n else:\n if os.path.exists(para_dic[\"gff_prok\"]) is False:\n parser.error(\"\"\"reference genome gff doesnt exist\"\"\")\n # for eukarya\n elif para_dic['kingdom'] in [\"eukarya\", \"both\"]:\n if para_dic[\"fasta_euk\"] is None:\n parser.error(\"\"\"eukarya requires fasta file to be specified using\n fasta_euk in config file\"\"\")\n else:\n if os.path.exists(para_dic[\"fasta_euk\"]) is False:\n parser.error(\"\"\"eukaryotic reference genome doesnt exist\"\"\")\n if para_dic[\"gff_euk\"] is None:\n parser.error(\"\"\"eukarya requires gff file to be specified using\n gff_euk in config file\"\"\") \n else:\n if os.path.exists(para_dic[\"gff_euk\"]) is False:\n parser.error(\"\"\"eukaryotic reference genome gff doesnt exist\"\"\")\n\n # if \"ballgown\" in para_dic['method'] and para_dic[\"kingdom\"] == \"prokarya\":\n # sys.exit(\"\"\"Ballgown does not work for prokaryotic genomes,\n # pick method that does not have ballgown!\"\"\")","def answer_input_validation():\r\n user_input_is_valid = False\r\n while user_input_is_valid == False:\r\n try:\r\n users_answer_to_problem = int(input(\"\\nEnter the answer to the addition problem: \"))\r\n user_input_is_valid = True\r\n break\r\n # The ValueError is used because the user must enter an integer. If the \r\n # answer given is not an integer, they are scolded and reprompted.\r\n except ValueError:\r\n user_input_is_valid = False\r\n print(\"That is not an integer. Please enter an appropriate answer.\")\r\n return users_answer_to_problem","def prompt_user_check_input(self):\r\n user_input = 0\r\n # grabs user input and changes it to an int\r\n while True:\r\n try:\r\n user_input = int(\r\n input(\"\\033[1;33mMake your move by entering the number of an open space on the board: \\033[0m\"))\r\n except ValueError:\r\n print(\"Why do you refuse to enter a number, Dave?\")\r\n continue\r\n else:\r\n break\r\n\r\n # makes sure the user enters a number 0-8 and verifies that the space the user selected is open\r\n if self.verify_valid_num(user_input) and self.write_user_choice(user_input):\r\n return True\r\n else:\r\n self.prompt_user_check_input()","def seal_is_valid(self):\n pass","def seal_is_valid(self):\n pass","def sanity_check(self):\n pass","def verify_text(self, text):\n pass","def check_input(naming):\n\n if naming not in ['label', 'id']:\n raise ValueError('naming must be \"label\" or \"id\"')","def validate_inputs(self, extra_inputs=[]):\n pass","def _validate(self):\n pass","def __check_errors(self):\n if not(\"input\" in self.passedArgs or \"source\" in self.passedArgs):\n raise ArgError(\"Program did not receive any of mandatory arguments! (--source=file, --input=file)\")","def _is_user_wants_to_continue(self):\n\n # dummy value to get in while\n user_input = -1\n while user_input != 1 and user_input != 2:\n\n try:\n # convert the string into int\n user_input = int(input())\n except ValueError:\n print(\"Please enter a number\")\n continue\n except Exception as e:\n print(\"something went wrong please try again \" + str(e))\n continue\n\n # check if the user_input was one of the options\n # if not present a error massage and try again\n if user_input != 1 and user_input != 2:\n print(\"Please enter a valid number(1-2)\")\n continue\n\n return user_input == 1","def test_validate_input_rejection_invalid_symbol(self):\n with nose.assert_raises(exceptions.RejectionError):\n self.dtm1.validate_input('02')","def __input_validator(msg):\n\n\t\tstatus = msg[\"status\"]\n\n\t\tif status == 1:\n\t\t\treturn status\n\t\telif status == 0:\n\t\t\tprint(msg[\"body\"])\n\t\telif status == -1:\n\t\t\tprint(\"Please enter something!\")\n\t\telif status == -2:\n\t\t\tprint(\"Your command {} is invalid\".format(msg[\"verb\"]))\n\t\telif status == -3:\n\t\t\tprint(\"No argument given after {}\".format(msg[\"verb\"]))","def check_additional_input():\r\n\r\n # Check if the cluster center input is correct\r\n RM.check_if_matrix(clust_cent, 'The cluster centers')\r\n RM.warn_if_bigger(clust_cent.shape[1], meta_model.get_in_par_means().shape[1],\r\n 'The number of input parameters in the cluster centers',\r\n 'the number of input parameters - 1')\r\n RM.check_if_bigger(clust_cent.shape[1], meta_model.get_in_par_means().shape[1] - 1,\r\n 'The number of input parameters',\r\n 'the number of input parameters in the cluster centers')\r\n\r\n bounds = meta_model.get_in_par_intervals()\r\n\r\n for j in range(clust_cent.shape[0]):\r\n for i in range(bounds.shape[0]):\r\n RM.check_if_in_interval(bounds[i], clust_cent[j, i], i, ' In cluster center %x, the value')\r\n\r\n def check_PLSR_input():\r\n \"\"\" Checks model data of PLSR\r\n\r\n :return: Checks model data of PLSR\r\n \"\"\"\r\n\r\n RM.check_if_ndim_array(model_data, 3, 'Model data')\r\n RM.check_if_bigger(model_data.shape[1], meta_model.get_in_par_means().shape[1],\r\n 'The number of input parameters in the solution matrix',\r\n 'the number of input parameters')\r\n RM.warn_if_bigger(model_data.shape[1], meta_model.get_in_par_means().shape[1] + 1,\r\n 'The number of input parameters',\r\n 'the number of input parameters in the solution matrix')\r\n RM.check_if_bigger(model_data.shape[2], meta_model.get_out_par_means().shape[1] - 1,\r\n 'The number of output parameters in the solution matrix',\r\n 'the number of output parameters')\r\n RM.warn_if_bigger(model_data.shape[2], meta_model.get_out_par_means().shape[1],\r\n 'The number of output parameters',\r\n 'the number of output parameters in the solution matrix')\r\n\r\n # Check if the additional data is correct\r\n\r\n if meta_model.get_type() == 'PLSR': # Additional check-up for PLSR\r\n check_PLSR_input()\r\n\r\n elif meta_model.get_type() == 'DLU': # Additional check-up for DLU\r\n raise TypeError('This part is not implemented yet')\r\n\r\n # if not isinstance(model_data, np.ndarray):\r\n # raise TypeError('The cluster input and output data is not stored in a multidimensional array')\r\n #\r\n # for clust_data in model_data:\r\n #\r\n # if not isinstance(clust_data[0], np.matrix) or not isinstance(clust_data[1], np.matrix):\r\n # raise TypeError('One of the input or output databases is not a matrix')\r\n #\r\n # if clust_data[0].shape[1] > meta_model.get_in_par_means().shape[1]:\r\n # warnings.warn('The number of input parameters for the input database of the clusters is bigger '\r\n # 'than the actual number of input parameters')\r\n #\r\n # elif clust_data[0].shape[1] < meta_model.get_in_par_means().shape[1]:\r\n # raise TypeError('The number of input parameters for the input database of the clusters is '\r\n # 'smaller than the actual numbers of input parameters')\r\n #\r\n # if clust_data[1].shape[1] > meta_model.get_out_par_means().shape[1]:\r\n # raise TypeError('The number of output parameters for the output database of the clusters is '\r\n # 'bigger than the actual number of output parameters')\r\n #\r\n # elif clust_data[1].shape[1] < meta_model.get_out_par_means().shape[1]:\r\n # raise TypeError('The number of output parameters for the output database of the clusters is '\r\n # 'smaller than the actual numbers of output parameters')\r\n #\r\n # if clust_data[0].shape[0] != clust_data[1].shape[0]:\r\n # raise TypeError('The number rows in the input and output database differ from each other')\r\n\r\n else: # No check-up is done when the meta-model is an unknown version\r\n warnings.warn('The additional cluster data can not be checked, for this kind of meta-model')\r\n\r\n RM.check_if_same_size(clust_cent.shape[0], model_data.shape[0],\r\n 'The number of clusters according to the cluster centers',\r\n 'The number of clusters according to the model_data')","def check_sync_input(self, sync_params):\n for req_param in REQUIRED_PARAMS:\n if req_param not in sync_params:\n logger.error(\"Received request with missing '%s' parameter\", req_param)\n raise YKSyncError('MISSING_PARAMETER', req_param)\n if req_param not in ('otp', 'nonce', 'yk_publicname') and not \\\n (sync_params[req_param] == '-1' or isinstance(sync_params[req_param], int)):\n logger.error(\"Input parameter '%s' is not correct\", req_param)\n raise YKSyncError('INVALID_PARAMETER', req_param)","def check(self, input, ast):\n assert False # Must be redefined","def check_validity(self) -> None: # pylint: disable=no-self-use # pragma: nocover\n return None","def test_check_category_input_1(self):\n assert validation.check_category_input(1, []) == False","def continue_playing_validation():\r\n user_input_is_valid = False\r\n while user_input_is_valid == False:\r\n user_wants_another_problem = input(\"Would you like another problem, Y/N? \").lower()\r\n if user_wants_another_problem in [\"y\", \"n\"]:\r\n user_input_is_valid = True\r\n elif user_wants_another_problem not in [\"y\", \"n\"]:\r\n user_input_is_valid = False\r\n print(f\"The input you entered, '{user_wants_another_problem}', is not valid. Try again.\\n\")\r\n return user_wants_another_problem","def validate_input(value):\n try:\n values = ['1', '2', '3', '4']\n if value not in values:\n raise ValueError\n except ValueError:\n print(f\"Invalid selection, you typed '{value}'. Please try again.\\n\")\n print('-' * 80)\n return False\n else:\n return True","def validate_answer(self, answer):\r\n try:\r\n evaluator(dict(), dict(), answer)\r\n return True\r\n except (StudentInputError, UndefinedVariable):\r\n return False","def verify_signature(self, inputs, signature):\n pass","def verify_signature(self, inputs, signature):\n pass","def validate_answer(self, answer):\r\n var_dict_list = self.randomize_variables(self.samples)\r\n try:\r\n self.tupleize_answers(answer, var_dict_list)\r\n return True\r\n except StudentInputError:\r\n return False","def _verify(self):\n pass","def checkValid(self):\n if (self.noteName is not None) and (self.accidental is not None) and (self.octave is not None):\n return True\n else:\n return False","def test_validate(self):\n pass","def check_inputs(self, item_data):\n if not item_data[0] in self.data['pizza']:\n print('Error: ' + item_data[0] + ' pizza does not exist.')\n return False\n\n if not item_data[1] in self.data['pizza'][item_data[0]]:\n print('Error: ' + item_data[1] + ' size does not exist for '\n + item_data[0] + ' pizza.')\n return False\n\n for topping in item_data[2]:\n if not topping in self.data['topping']:\n print('Error: Pizza topping ' + topping + ' does not exist.')\n return False\n return True","def input_validation(input_: str) -> bool:\n return fullmatch('[1-9]', input_) is not None","def Check(self, parameters):"],"string":"[\n \"def check_validity(self):\",\n \"def isInputValid(self, input):\\r\\n pass\",\n \"def validate():\",\n \"def validate_input(self, *args):\\n return\",\n \"def verify():\",\n \"def validate_user_input(user_input):\\n responses = ['t', 'r', 'q']\\n return user_input in responses\",\n \"def test_valid_user_input(self):\\n\\n test_name = sys._getframe().f_code.co_name\\n\\n log.info(\\\"###### TEST EXECUTION STARTED :: \\\" + test_name + \\\" ######\\\")\\n\\n user_input = data_reader.get_data(test_name, \\\"Text_Message\\\")\\n\\n with allure.step(\\\"Verify User Input\\\"):\\n result = self.main_page.verify_valid_user_input(user_input)\\n self.exe_status.mark_final(test_step=test_name, result=result)\",\n \"def check():\",\n \"def _check_validity(self):\\n pass\",\n \"def validate_input():\\n pass_length = None\\n account_name = None\\n method = None\\n in_value = None\\n parser = ArgumentParser()\\n parser.add_argument(\\\"-l\\\", \\\"--length\\\",\\n type=int,\\n help=\\\"length of password\\\")\\n\\n parser.add_argument(\\\"-a\\\", \\\"--account\\\",\\n help=\\\"account or site name\\\")\\n\\n parser.add_argument(\\\"-m\\\", \\\"--method\\\",\\n help=\\\"method to take [S|C|R|U|D]\\\")\\n\\n parser.add_argument(\\\"-v\\\", \\\"--value\\\",\\n help=\\\"Do not generate, store this value\\\")\\n\\n args = parser.parse_args()\\n if args.length:\\n pass_length = int(args.length)\\n\\n if args.account:\\n account_name = str(args.account)\\n\\n if args.method:\\n method = str.upper(args.method)\\n\\n if args.value:\\n in_value = str(args.value)\\n\\n return (pass_length, account_name, method, in_value)\",\n \"def verify(self):\\n data = [\\\"rfc\\\", \\\"tel\\\", \\\"email\\\", \\\"name\\\", \\\"use\\\"]\\n state = False\\n for item in data:\\n if getattr(self, item + \\\"Input\\\").text() != \\\"\\\":\\n state = True\\n else:\\n return False\\n return state\",\n \"def _check_inputs(self):\\n\\n self._check_resident_prefs()\\n self._check_hospital_prefs()\",\n \"def _check_for_incomplete_input(self):\\n pass\",\n \"def are_input_correct(self):\\n\\n\\t\\tname_user = self.check_this_input(self.entrada_usr, 100)\\n\\t\\tpass_user = self.check_this_input(self.entrada_pwd, 72)\\n\\n\\t\\treturn name_user,pass_user\",\n \"def validate_input(self):\\n if (self.options.mexURL and self.options.token): #run module through engine service\\n return True\\n\\n if (self.options.user and self.options.pwd and self.options.root): #run module locally (note: to test module)\\n return True\\n\\n log.debug('Dream3D: Insufficient options or arguments to start this module')\\n return False\",\n \"def test_input2(self):\\n in1 =\\\"aple\\\"\\n result = options.checkw(in1)\\n self.assertEqual(result,False)\",\n \"def test_validate_input_rejection(self):\\n with nose.assert_raises(exceptions.RejectionError):\\n self.dtm1.validate_input('000011')\",\n \"def validateInput(self): \\n if (self.options.mexURL and self.options.token): #run module through engine service\\n return True\\n \\n if (self.options.user and self.options.pwd and self.options.root): #run module locally (note: to test module)\\n return True\\n \\n log.debug('Botanicam: Insufficient options or arguments to start this module')\\n return False\",\n \"def test_validate_input_good_input(self):\\r\\n _validate_input(self.dist_matrix_header, self.dist_matrix,\\r\\n self.mapping_header, self.mapping, \\\"Treatment\\\")\",\n \"def main():\\n user_input = user_input_state()\\n check_user_input(user_input)\",\n \"def __checkInput(self, var):\\n try:\\n int(var)\\n\\n except:\\n return False\\n\\n else:\\n return True\",\n \"def validate(info):\\n\\n\\tif info == \\\"\\\": \\n\\t\\treturn False\\n\\telse:\\n\\t\\tif len(info) < 5 or len(info) > 32:\\n\\t\\t\\treturn False\\n\\t\\telse:\\n\\t\\t\\treturn True\",\n \"def checkUserInput(self):\\n prm = []\\n err = \\\"\\\"\\n guess = self.text.text()\\n items = str(guess).split(',')\\n if len(items) != 2:\\n err = \\\"Two parameters must be given\\\"\\n else:\\n for i in range(0, len(items)):\\n val = items[i].strip()\\n if not isNumber(val):\\n err = \\\"Parameter {0} is not numeric\\\".format(i + 1)\\n break\\n if float(val) < 0.0:\\n err = \\\"Parameter {0} is negative\\\".format(i + 1)\\n break\\n val = float(val)\\n if i == 0 and val > self.yspan:\\n err = \\\"minHeight is too large\\\"\\n break\\n if i == 1:\\n if val < self.xspan/self.npt or val > self.xspan/2:\\n err = \\\"minWidth is too large\\\"\\n break\\n prm.append(val)\\n if err:\\n errmsg = \\\"Incorrect input:\\\\n{0}\\\".format(err)\\n QtWidgets.QMessageBox.warning(self, self.title, errmsg)\\n return False\\n\\n # Store parameters values in global variables for the next call\\n global lastfilename, lastmph, lastmpw\\n lastfilename = self.pltw.filename\\n self.mph = lastmph = prm[0]\\n self.mpw = lastmpw = prm[1]\\n return True\",\n \"def _verify_arguments(self):\\n # if self.options.action == \\\"create\\\":\\n # if self.options.encrypt_payload and not self.options.payload_secret:\\n # self.parser.error('A secret must be supplied with --payload-secret option when the --encrypt-payload option is in use.')\\n pass\",\n \"def check_all_user_inputs_valid(self):\\n self.check_RNN_layers_valid()\\n self.check_activations_valid()\\n self.check_embedding_dimensions_valid()\\n self.check_initialiser_valid()\\n self.check_y_range_values_valid()\\n self.check_return_final_seq_only_valid()\",\n \"def input_check(self):\\n\\n if self.species == 'He': assert self.line_model == 'voigt'\\n n_upper_range, e_dens_range, temp_range, b_field_range = get_param_ranges(self.line_model)\\n\\n if np.isnan(n_upper_range).sum() <= 1:\\n assert (self.n_upper in range(n_upper_range[0], n_upper_range[1]))\\n if np.isnan(e_dens_range).sum() <= 1:\\n assert (e_dens_range[0] <= self.e_dens <= e_dens_range[1])\\n if np.isnan(temp_range).sum() <= 1:\\n assert (temp_range[0] <= self.temp <= temp_range[1])\\n if np.isnan(b_field_range).sum() <= 1:\\n assert (b_field_range[0] <= self.b_field <= b_field_range[1])\",\n \"def input_validation(self, prompt):\\r\\n\\r\\n while True:\\r\\n try:\\r\\n x, y = map(int, input(prompt).split())\\r\\n except ValueError: # when there is less than or more than 2 input values\\r\\n print('Invalid input try again.')\\r\\n continue\\r\\n if (x != self.selected[0]) or (y != self.selected[1]): # different from first choice\\r\\n if (0 <= x <= 3) and (0 <= y <= 12): # Valid input\\r\\n if not ([x, y] in self.bin): # Check if this card is still there or not\\r\\n break\\r\\n else:\\r\\n print('This card has already been taken.')\\r\\n continue\\r\\n else: # invalid input\\r\\n print('Row and column should be from 0 to 3 and 1 to 12 respectively.')\\r\\n continue\\r\\n else:\\r\\n print('Choose a card different from your first choice')\\r\\n continue\\r\\n return x, y\",\n \"def check(self):\\n view_keys(self.d)\\n paso1=input('Do you want to change any parameter?(y/n)\\\\n')\\n while paso1[0] == 'y':\\n key=input('Which one?\\\\n')\\n if key not in self.d:\\n paso2=input(\\\"This parameter is not in the dictionary.\\\\\\nDo you want to include it?(y/n)\\\\n\\\")\\n if paso2[0]=='y':\\n value=input('value(s) of '+key+'?= ')\\n self.d[key]=tuple(split(replace(value,',',' ')))\\n else:continue\\n else:\\n value=input('New value(s) of '+key+'?= ')\\n self.d[key]=tuple(split(replace(value,',',' ')))\\n view_keys(self.d)\\n paso1=input('Anything else?(y/n)\\\\n')\",\n \"def verify_prompt(prompt: str, expected: str = \\\"y\\\"):\\n input_ = input(prompt)\\n if input_ != expected:\\n raise ValidationError(f\\\"Expected {expected}, got {input_}\\\")\",\n \"def __validate():\\n # TODO: implement\",\n \"def validate(self):\\n return (self.check_input_digits_count()\\n and self.check_if_input_is_int()\\n and self.check_if_input_digits_are_unique())\",\n \"def check_vulnerability(self):\\n\\t\\tpass\",\n \"def validate_input(user_input: str) -> bool:\\n\\n if not user_input.islower():\\n return False\\n\\n if user_input.endswith(\\\"yeet\\\"):\\n return False\\n \\n if \\\"q\\\" or \\\"Q\\\" in user_input: # Check if q is a letter\\n return False\\n \\n return True # If none of the conditions above are met\",\n \"def check(self) -> None:\",\n \"def validate_action(self, message=\\\"This action may delete data from the database. This action cannot be undone.\\\\nDo you wish to continue? (Y/N): \\\"):\\n \\n while True:\\n print('\\\\n\\\\n')\\n inp = input(message)\\n \\n if (inp.upper() == 'Y'):\\n return True\\n elif (inp.upper() == 'N'):\\n return False\\n \\n print(\\\"Invalid input. Try again\\\")\",\n \"def check_input(saved_input):\\n if saved_input.lower() == \\\"!yes\\\":\\n return True\\n if saved_input.lower() == \\\"!no\\\":\\n return False\",\n \"def _validate_input(self):\\n self.data.validate()\\n self.meta_hybridizer.validate_input()\",\n \"def first_is_valid(command_from_user):\\n arguement_entered_user = command_from_user[0]\\n if arguement_entered_user == 'list':\\n return True\\n \\n elif arguement_entered_user == 'clashes':\\n return True\\n \\n else:\\n return False\",\n \"def test_validate_input_valid(self):\\n final_config = self.dtm1.validate_input('00001111')\\n nose.assert_equal(final_config[0], 'q4')\\n nose.assert_equal(str(final_config[1]), 'TMTape(\\\\'xxxxyyyy.\\\\')')\",\n \"def validate(self):\",\n \"def validate(self):\",\n \"def question_new_validate():\",\n \"def test_input1(self):\\n in1 =\\\"elephant\\\"\\n result = options.check(in1)\\n self.assertEqual(result,True)\",\n \"def checkInput(userInput):\\n if userInput == 'exit':\\n return 0\\n return 1\",\n \"def validate(self):\\r\\n return 1\",\n \"def validate(self):\\r\\n return 1\",\n \"def validate(self):\\r\\n return 1\",\n \"def validate(self):\\r\\n return 1\",\n \"def validate(self):\\r\\n return 1\",\n \"def __check_validation(input_string):\\n if not input_string:\\n raise NullInputException(\\\"Input string should be not empty\\\")\\n if type(input_string) != str:\\n raise NonStringInputException(\\\"Input value should be a string\\\")\\n if len(input_string) >= 200:\\n raise TooLongInputException(\\\"Input string should be less than 200 characters\\\")\\n for i in input_string:\\n if not i.isalpha():\\n raise NonStringInputException(\\\"All input value characters should be an alpha\\\")\",\n \"def validate(ob):\",\n \"def test_check_validity(\\n student_names, project_names, supervisor_names, capacities, seed, clean\\n):\\n\\n *_, game = make_game(\\n student_names, project_names, supervisor_names, capacities, seed, clean\\n )\\n\\n game.solve()\\n assert game.check_validity()\",\n \"async def validate(self, ctx: Context, argument: str) -> bool:\\n return True\",\n \"def violated(self) -> bool:\\n ...\",\n \"def validate(self):\\n return 1\",\n \"def valid_args(args):\\n is_valid = True\\n if not args.ts_url or not args.username or not args.password or not args.from_user or not args.to_user:\\n eprint(\\\"Missing required parameters.\\\")\\n is_valid = False\\n\\n return is_valid\",\n \"def _validate(self, *_):\\n provider = self.provider_entry.get_text()\\n username = self.account_name_entry.get_text()\\n token = \\\"\\\".join(self.token_entry.get_text().split())\\n\\n if not username:\\n self.account_name_entry.get_style_context().add_class(\\\"error\\\")\\n valid_name = False\\n else:\\n self.account_name_entry.get_style_context().remove_class(\\\"error\\\")\\n valid_name = True\\n\\n if not provider:\\n self.provider_combobox.get_style_context().add_class(\\\"error\\\")\\n valid_provider = False\\n else:\\n self.provider_combobox.get_style_context().remove_class(\\\"error\\\")\\n valid_provider = True\\n\\n if (not token or not OTP.is_valid(token)) and not self.props.is_edit:\\n self.token_entry.get_style_context().add_class(\\\"error\\\")\\n valid_token = False\\n else:\\n self.token_entry.get_style_context().remove_class(\\\"error\\\")\\n valid_token = True\\n\\n self.emit(\\\"changed\\\", all([valid_name, valid_provider, valid_token]))\",\n \"def valid(self):\\n pass\",\n \"def validate_command_line_input(args):\\n valid = False\\n if 0 < len(args) <= 4:\\n valid = True\\n for arg in args:\\n if int(arg) > 4:\\n valid = False\\n break\\n else:\\n pass\\n if valid:\\n CRUDStarter.load_operations(args)\\n pass\\n else:\\n CRUDStarter.logger.info(\\\"Argument maximum acceptable value is 4\\\")\\n else:\\n CRUDStarter.logger.info(\\\"at least One at most Four argument(s) required\\\")\",\n \"def _is_valid(self):\\n self._is_allows_valid()\\n self._is_denies_valid()\",\n \"def verify(self):\",\n \"def validate(self):\\n stguess = self.text.toPlainText()\\n if not self.pkfitdlg.checkUserInput(stguess):\\n return\\n self.stguess = stguess\\n self.accept()\",\n \"def valid_response(prompt, *valid):\\r\\n ans = console_input(prompt).lower()\\r\\n\\r\\n if ans in valid:\\r\\n return True\\r\\n elif ans == '':\\r\\n return None\\r\\n\\r\\n return False\",\n \"def wizard_input_verification(form):\\n # Note,that key must start with line_..., other options are ignored, to allow DNF option to work\\n lines = [value for key, value in form.items() if key.startswith(\\\"line\\\")]\\n # if the entered lines are unique, they will have the same value\\n if len(lines) != len(set(lines)):\\n return False\\n else:\\n return True\",\n \"def check(self, input, node):\\n assert False # Must be redefined\",\n \"def sanity_check(self):\\n return True\",\n \"def check_input(the_user_entry):\\n try:\\n for z in range(length_of_bad_input):\\n if bad_input[z] == the_user_entry:\\n messagebox.showwarning(title=\\\"Invalid input!\\\",\\n message=\\\"The following characters are forbidden:\\\\n\\\"\\n \\\"~`!@#$%^&*()_-+={[}]|\\\\\\\\:;\\\\\\\"\\\\'<,>.?/1234567890\\\")\\n clear_box()\\n raise ValueError\\n except ValueError:\\n print(\\\"The user entered an invalid character in the entry box\\\\n\\\"\\n \\\"potentially one of the following:\\\\n\\\"\\n \\\"~`!@#$%^&*()_-+={[}]|\\\\\\\\:;\\\\\\\"\\\\'<,>.?/1234567890\\\")\",\n \"def validate(self):\\n try:\\n self.values.clear()\\n self.values.append(int(self.e1.get()))\\n except ValueError:\\n messagebox.showwarning(\\n \\\"Bad input\\\",\\n \\\"Illegal values, please try again.\\\")\\n return False\\n\\n return True\",\n \"def __check_inputs__(self):\\n # | - __check_inputs__\\n # #####################################################################\\n stop_mode = self.stop_mode\\n stop_num_generations = self.stop_num_generations\\n # #####################################################################\\n\\n if stop_mode == \\\"num_generations\\\":\\n mess_i = \\\"stop_mode='num_generations', \\\\\\n Must pass int to 'stop_num_generations'\\\"\\n assert type(stop_num_generations) == type(1), mess_i\\n #__|\",\n \"def checkCorrectness(self):\\n self.checkNeededParams()\\n if self.getParam(\\\"help\\\") == True:\\n return False\\n return True\",\n \"def check_input(para_dic, parser):\\n # for prokarya\\n if para_dic['kingdom'] in [\\\"prokarya\\\", \\\"both\\\"]:\\n if para_dic[\\\"fasta_prok\\\"] is None:\\n parser.error(\\\"\\\"\\\"prokarya requires fasta file to be specified using\\n fasta_prok in config file\\\"\\\"\\\")\\n else:\\n if os.path.exists(para_dic[\\\"fasta_prok\\\"]) is False:\\n parser.error(\\\"\\\"\\\"reference genome doesnt exist\\\"\\\"\\\")\\n if para_dic[\\\"gff_prok\\\"] is None:\\n parser.error(\\\"\\\"\\\"prokarya requires gff file to be specified using\\n gff_prok in config file\\\"\\\"\\\")\\n else:\\n if os.path.exists(para_dic[\\\"gff_prok\\\"]) is False:\\n parser.error(\\\"\\\"\\\"reference genome gff doesnt exist\\\"\\\"\\\")\\n # for eukarya\\n elif para_dic['kingdom'] in [\\\"eukarya\\\", \\\"both\\\"]:\\n if para_dic[\\\"fasta_euk\\\"] is None:\\n parser.error(\\\"\\\"\\\"eukarya requires fasta file to be specified using\\n fasta_euk in config file\\\"\\\"\\\")\\n else:\\n if os.path.exists(para_dic[\\\"fasta_euk\\\"]) is False:\\n parser.error(\\\"\\\"\\\"eukaryotic reference genome doesnt exist\\\"\\\"\\\")\\n if para_dic[\\\"gff_euk\\\"] is None:\\n parser.error(\\\"\\\"\\\"eukarya requires gff file to be specified using\\n gff_euk in config file\\\"\\\"\\\") \\n else:\\n if os.path.exists(para_dic[\\\"gff_euk\\\"]) is False:\\n parser.error(\\\"\\\"\\\"eukaryotic reference genome gff doesnt exist\\\"\\\"\\\")\\n\\n # if \\\"ballgown\\\" in para_dic['method'] and para_dic[\\\"kingdom\\\"] == \\\"prokarya\\\":\\n # sys.exit(\\\"\\\"\\\"Ballgown does not work for prokaryotic genomes,\\n # pick method that does not have ballgown!\\\"\\\"\\\")\",\n \"def answer_input_validation():\\r\\n user_input_is_valid = False\\r\\n while user_input_is_valid == False:\\r\\n try:\\r\\n users_answer_to_problem = int(input(\\\"\\\\nEnter the answer to the addition problem: \\\"))\\r\\n user_input_is_valid = True\\r\\n break\\r\\n # The ValueError is used because the user must enter an integer. If the \\r\\n # answer given is not an integer, they are scolded and reprompted.\\r\\n except ValueError:\\r\\n user_input_is_valid = False\\r\\n print(\\\"That is not an integer. Please enter an appropriate answer.\\\")\\r\\n return users_answer_to_problem\",\n \"def prompt_user_check_input(self):\\r\\n user_input = 0\\r\\n # grabs user input and changes it to an int\\r\\n while True:\\r\\n try:\\r\\n user_input = int(\\r\\n input(\\\"\\\\033[1;33mMake your move by entering the number of an open space on the board: \\\\033[0m\\\"))\\r\\n except ValueError:\\r\\n print(\\\"Why do you refuse to enter a number, Dave?\\\")\\r\\n continue\\r\\n else:\\r\\n break\\r\\n\\r\\n # makes sure the user enters a number 0-8 and verifies that the space the user selected is open\\r\\n if self.verify_valid_num(user_input) and self.write_user_choice(user_input):\\r\\n return True\\r\\n else:\\r\\n self.prompt_user_check_input()\",\n \"def seal_is_valid(self):\\n pass\",\n \"def seal_is_valid(self):\\n pass\",\n \"def sanity_check(self):\\n pass\",\n \"def verify_text(self, text):\\n pass\",\n \"def check_input(naming):\\n\\n if naming not in ['label', 'id']:\\n raise ValueError('naming must be \\\"label\\\" or \\\"id\\\"')\",\n \"def validate_inputs(self, extra_inputs=[]):\\n pass\",\n \"def _validate(self):\\n pass\",\n \"def __check_errors(self):\\n if not(\\\"input\\\" in self.passedArgs or \\\"source\\\" in self.passedArgs):\\n raise ArgError(\\\"Program did not receive any of mandatory arguments! (--source=file, --input=file)\\\")\",\n \"def _is_user_wants_to_continue(self):\\n\\n # dummy value to get in while\\n user_input = -1\\n while user_input != 1 and user_input != 2:\\n\\n try:\\n # convert the string into int\\n user_input = int(input())\\n except ValueError:\\n print(\\\"Please enter a number\\\")\\n continue\\n except Exception as e:\\n print(\\\"something went wrong please try again \\\" + str(e))\\n continue\\n\\n # check if the user_input was one of the options\\n # if not present a error massage and try again\\n if user_input != 1 and user_input != 2:\\n print(\\\"Please enter a valid number(1-2)\\\")\\n continue\\n\\n return user_input == 1\",\n \"def test_validate_input_rejection_invalid_symbol(self):\\n with nose.assert_raises(exceptions.RejectionError):\\n self.dtm1.validate_input('02')\",\n \"def __input_validator(msg):\\n\\n\\t\\tstatus = msg[\\\"status\\\"]\\n\\n\\t\\tif status == 1:\\n\\t\\t\\treturn status\\n\\t\\telif status == 0:\\n\\t\\t\\tprint(msg[\\\"body\\\"])\\n\\t\\telif status == -1:\\n\\t\\t\\tprint(\\\"Please enter something!\\\")\\n\\t\\telif status == -2:\\n\\t\\t\\tprint(\\\"Your command {} is invalid\\\".format(msg[\\\"verb\\\"]))\\n\\t\\telif status == -3:\\n\\t\\t\\tprint(\\\"No argument given after {}\\\".format(msg[\\\"verb\\\"]))\",\n \"def check_additional_input():\\r\\n\\r\\n # Check if the cluster center input is correct\\r\\n RM.check_if_matrix(clust_cent, 'The cluster centers')\\r\\n RM.warn_if_bigger(clust_cent.shape[1], meta_model.get_in_par_means().shape[1],\\r\\n 'The number of input parameters in the cluster centers',\\r\\n 'the number of input parameters - 1')\\r\\n RM.check_if_bigger(clust_cent.shape[1], meta_model.get_in_par_means().shape[1] - 1,\\r\\n 'The number of input parameters',\\r\\n 'the number of input parameters in the cluster centers')\\r\\n\\r\\n bounds = meta_model.get_in_par_intervals()\\r\\n\\r\\n for j in range(clust_cent.shape[0]):\\r\\n for i in range(bounds.shape[0]):\\r\\n RM.check_if_in_interval(bounds[i], clust_cent[j, i], i, ' In cluster center %x, the value')\\r\\n\\r\\n def check_PLSR_input():\\r\\n \\\"\\\"\\\" Checks model data of PLSR\\r\\n\\r\\n :return: Checks model data of PLSR\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n RM.check_if_ndim_array(model_data, 3, 'Model data')\\r\\n RM.check_if_bigger(model_data.shape[1], meta_model.get_in_par_means().shape[1],\\r\\n 'The number of input parameters in the solution matrix',\\r\\n 'the number of input parameters')\\r\\n RM.warn_if_bigger(model_data.shape[1], meta_model.get_in_par_means().shape[1] + 1,\\r\\n 'The number of input parameters',\\r\\n 'the number of input parameters in the solution matrix')\\r\\n RM.check_if_bigger(model_data.shape[2], meta_model.get_out_par_means().shape[1] - 1,\\r\\n 'The number of output parameters in the solution matrix',\\r\\n 'the number of output parameters')\\r\\n RM.warn_if_bigger(model_data.shape[2], meta_model.get_out_par_means().shape[1],\\r\\n 'The number of output parameters',\\r\\n 'the number of output parameters in the solution matrix')\\r\\n\\r\\n # Check if the additional data is correct\\r\\n\\r\\n if meta_model.get_type() == 'PLSR': # Additional check-up for PLSR\\r\\n check_PLSR_input()\\r\\n\\r\\n elif meta_model.get_type() == 'DLU': # Additional check-up for DLU\\r\\n raise TypeError('This part is not implemented yet')\\r\\n\\r\\n # if not isinstance(model_data, np.ndarray):\\r\\n # raise TypeError('The cluster input and output data is not stored in a multidimensional array')\\r\\n #\\r\\n # for clust_data in model_data:\\r\\n #\\r\\n # if not isinstance(clust_data[0], np.matrix) or not isinstance(clust_data[1], np.matrix):\\r\\n # raise TypeError('One of the input or output databases is not a matrix')\\r\\n #\\r\\n # if clust_data[0].shape[1] > meta_model.get_in_par_means().shape[1]:\\r\\n # warnings.warn('The number of input parameters for the input database of the clusters is bigger '\\r\\n # 'than the actual number of input parameters')\\r\\n #\\r\\n # elif clust_data[0].shape[1] < meta_model.get_in_par_means().shape[1]:\\r\\n # raise TypeError('The number of input parameters for the input database of the clusters is '\\r\\n # 'smaller than the actual numbers of input parameters')\\r\\n #\\r\\n # if clust_data[1].shape[1] > meta_model.get_out_par_means().shape[1]:\\r\\n # raise TypeError('The number of output parameters for the output database of the clusters is '\\r\\n # 'bigger than the actual number of output parameters')\\r\\n #\\r\\n # elif clust_data[1].shape[1] < meta_model.get_out_par_means().shape[1]:\\r\\n # raise TypeError('The number of output parameters for the output database of the clusters is '\\r\\n # 'smaller than the actual numbers of output parameters')\\r\\n #\\r\\n # if clust_data[0].shape[0] != clust_data[1].shape[0]:\\r\\n # raise TypeError('The number rows in the input and output database differ from each other')\\r\\n\\r\\n else: # No check-up is done when the meta-model is an unknown version\\r\\n warnings.warn('The additional cluster data can not be checked, for this kind of meta-model')\\r\\n\\r\\n RM.check_if_same_size(clust_cent.shape[0], model_data.shape[0],\\r\\n 'The number of clusters according to the cluster centers',\\r\\n 'The number of clusters according to the model_data')\",\n \"def check_sync_input(self, sync_params):\\n for req_param in REQUIRED_PARAMS:\\n if req_param not in sync_params:\\n logger.error(\\\"Received request with missing '%s' parameter\\\", req_param)\\n raise YKSyncError('MISSING_PARAMETER', req_param)\\n if req_param not in ('otp', 'nonce', 'yk_publicname') and not \\\\\\n (sync_params[req_param] == '-1' or isinstance(sync_params[req_param], int)):\\n logger.error(\\\"Input parameter '%s' is not correct\\\", req_param)\\n raise YKSyncError('INVALID_PARAMETER', req_param)\",\n \"def check(self, input, ast):\\n assert False # Must be redefined\",\n \"def check_validity(self) -> None: # pylint: disable=no-self-use # pragma: nocover\\n return None\",\n \"def test_check_category_input_1(self):\\n assert validation.check_category_input(1, []) == False\",\n \"def continue_playing_validation():\\r\\n user_input_is_valid = False\\r\\n while user_input_is_valid == False:\\r\\n user_wants_another_problem = input(\\\"Would you like another problem, Y/N? \\\").lower()\\r\\n if user_wants_another_problem in [\\\"y\\\", \\\"n\\\"]:\\r\\n user_input_is_valid = True\\r\\n elif user_wants_another_problem not in [\\\"y\\\", \\\"n\\\"]:\\r\\n user_input_is_valid = False\\r\\n print(f\\\"The input you entered, '{user_wants_another_problem}', is not valid. Try again.\\\\n\\\")\\r\\n return user_wants_another_problem\",\n \"def validate_input(value):\\n try:\\n values = ['1', '2', '3', '4']\\n if value not in values:\\n raise ValueError\\n except ValueError:\\n print(f\\\"Invalid selection, you typed '{value}'. Please try again.\\\\n\\\")\\n print('-' * 80)\\n return False\\n else:\\n return True\",\n \"def validate_answer(self, answer):\\r\\n try:\\r\\n evaluator(dict(), dict(), answer)\\r\\n return True\\r\\n except (StudentInputError, UndefinedVariable):\\r\\n return False\",\n \"def verify_signature(self, inputs, signature):\\n pass\",\n \"def verify_signature(self, inputs, signature):\\n pass\",\n \"def validate_answer(self, answer):\\r\\n var_dict_list = self.randomize_variables(self.samples)\\r\\n try:\\r\\n self.tupleize_answers(answer, var_dict_list)\\r\\n return True\\r\\n except StudentInputError:\\r\\n return False\",\n \"def _verify(self):\\n pass\",\n \"def checkValid(self):\\n if (self.noteName is not None) and (self.accidental is not None) and (self.octave is not None):\\n return True\\n else:\\n return False\",\n \"def test_validate(self):\\n pass\",\n \"def check_inputs(self, item_data):\\n if not item_data[0] in self.data['pizza']:\\n print('Error: ' + item_data[0] + ' pizza does not exist.')\\n return False\\n\\n if not item_data[1] in self.data['pizza'][item_data[0]]:\\n print('Error: ' + item_data[1] + ' size does not exist for '\\n + item_data[0] + ' pizza.')\\n return False\\n\\n for topping in item_data[2]:\\n if not topping in self.data['topping']:\\n print('Error: Pizza topping ' + topping + ' does not exist.')\\n return False\\n return True\",\n \"def input_validation(input_: str) -> bool:\\n return fullmatch('[1-9]', input_) is not None\",\n \"def Check(self, parameters):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7332497","0.7278962","0.7278766","0.71752334","0.68487245","0.6826624","0.68062013","0.6788392","0.6787829","0.66582745","0.6449319","0.64325076","0.6425667","0.63953435","0.6345437","0.632387","0.6322956","0.6319321","0.6303776","0.62568563","0.6250406","0.6242733","0.6238996","0.6235785","0.6214237","0.62115616","0.6196684","0.61763686","0.6168225","0.6165208","0.6164465","0.6157124","0.61540675","0.6151517","0.6144974","0.6142173","0.61302423","0.61300826","0.61127853","0.6110766","0.6110766","0.60979027","0.60937005","0.6086586","0.6085079","0.6085079","0.6085079","0.6085079","0.6085079","0.6069942","0.6060525","0.60559577","0.60539526","0.60479295","0.6045083","0.60349286","0.6029133","0.60231185","0.6017696","0.6015996","0.60157","0.60060275","0.600266","0.5990367","0.5969938","0.59674764","0.5965363","0.59568477","0.5945505","0.5945189","0.593054","0.5925891","0.59172684","0.5907825","0.5907825","0.59052914","0.5901907","0.5897954","0.5897816","0.58943456","0.5890069","0.58898026","0.58881944","0.5884656","0.5881133","0.5880312","0.58739513","0.58716893","0.5870613","0.58639634","0.5859525","0.58573246","0.5852182","0.5852182","0.5838337","0.5837543","0.58356255","0.5832491","0.5829896","0.58221185","0.5818872"],"string":"[\n \"0.7332497\",\n \"0.7278962\",\n \"0.7278766\",\n \"0.71752334\",\n \"0.68487245\",\n \"0.6826624\",\n \"0.68062013\",\n \"0.6788392\",\n \"0.6787829\",\n \"0.66582745\",\n \"0.6449319\",\n \"0.64325076\",\n \"0.6425667\",\n \"0.63953435\",\n \"0.6345437\",\n \"0.632387\",\n \"0.6322956\",\n \"0.6319321\",\n \"0.6303776\",\n \"0.62568563\",\n \"0.6250406\",\n \"0.6242733\",\n \"0.6238996\",\n \"0.6235785\",\n \"0.6214237\",\n \"0.62115616\",\n \"0.6196684\",\n \"0.61763686\",\n \"0.6168225\",\n \"0.6165208\",\n \"0.6164465\",\n \"0.6157124\",\n \"0.61540675\",\n \"0.6151517\",\n \"0.6144974\",\n \"0.6142173\",\n \"0.61302423\",\n \"0.61300826\",\n \"0.61127853\",\n \"0.6110766\",\n \"0.6110766\",\n \"0.60979027\",\n \"0.60937005\",\n \"0.6086586\",\n \"0.6085079\",\n \"0.6085079\",\n \"0.6085079\",\n \"0.6085079\",\n \"0.6085079\",\n \"0.6069942\",\n \"0.6060525\",\n \"0.60559577\",\n \"0.60539526\",\n \"0.60479295\",\n \"0.6045083\",\n \"0.60349286\",\n \"0.6029133\",\n \"0.60231185\",\n \"0.6017696\",\n \"0.6015996\",\n \"0.60157\",\n \"0.60060275\",\n \"0.600266\",\n \"0.5990367\",\n \"0.5969938\",\n \"0.59674764\",\n \"0.5965363\",\n \"0.59568477\",\n \"0.5945505\",\n \"0.5945189\",\n \"0.593054\",\n \"0.5925891\",\n \"0.59172684\",\n \"0.5907825\",\n \"0.5907825\",\n \"0.59052914\",\n \"0.5901907\",\n \"0.5897954\",\n \"0.5897816\",\n \"0.58943456\",\n \"0.5890069\",\n \"0.58898026\",\n \"0.58881944\",\n \"0.5884656\",\n \"0.5881133\",\n \"0.5880312\",\n \"0.58739513\",\n \"0.58716893\",\n \"0.5870613\",\n \"0.58639634\",\n \"0.5859525\",\n \"0.58573246\",\n \"0.5852182\",\n \"0.5852182\",\n \"0.5838337\",\n \"0.5837543\",\n \"0.58356255\",\n \"0.5832491\",\n \"0.5829896\",\n \"0.58221185\",\n \"0.5818872\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12892,"cells":{"query":{"kind":"string","value":"Creates a millisecond based timestamp of UTC now."},"document":{"kind":"string","value":"def get_utc_now_timestamp() -> int:\n return int(datetime.datetime.now(datetime.timezone.utc).timestamp() * 1000)"},"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 Now():\n ut = (datetime.datetime.utcnow() - _EPOCH).total_seconds() / 86400.0\n return Time(ut)","def now() -> datetime:\n now = datetime.now(tz=timezone.utc)\n return now.replace(microsecond=now.microsecond - now.microsecond % 1000)","def now_timestamp(unit: TimeUnit = TimeUnit.SECONDS) -> float:\n return TimeHelper.to_timestamp(TimeHelper.now(), unit)","def utcnow_ts():\r\n return calendar.timegm(utcnow().timetuple())","def _create_timestamp():\n return (datetime.utcnow() - datetime(1970,1,1)).total_seconds()","def now_s():\n return calendar.timegm(now_dt().utctimetuple())","def getNowMilliseconds():\n return (datetime.datetime.utcnow() - Common.epoch_).total_seconds() * 1000.0","def get_now_utc(no_microseconds=True):\n if no_microseconds:\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\n microsecond=0\n )\n else:\n return pytz.utc.localize(datetime.datetime.utcnow())","def get_now_utc(no_microseconds=True):\n if no_microseconds:\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\n microsecond=0\n )\n else:\n return pytz.utc.localize(datetime.datetime.utcnow())","def now():\n return utcfromtimestamp(time.time())","def utc_millisecond_timestamp():\n return __date_to_millisecond_ts(utc())","def local_timestamp():\n # type: () -> int\n now = datetime.utcnow()\n timestamp_in_seconds = calendar.timegm(now.timetuple()) + (now.microsecond / 1e6)\n timestamp_in_milliseconds = int(timestamp_in_seconds * 1000)\n return timestamp_in_milliseconds","def nowUTC():\n return datetime.datetime.now(pytz.utc)","def _nowms():\n return int(time.time() * 1000)","def default_timestamp():\n date = datetime.datetime.now().replace(microsecond=0)\n return date","def current_time_millis():\n return int(round(time.time() * 1000))","def now():\n return int(datetime.datetime.now().strftime(\"%s\")) * 1000","def timestamp(millis=False):\n return int(round(time.time() * (millis and 1000 or 1)))","def tstamp_now(self):\n return self.tstamp(datetime.datetime.now(tz))","def get_now_hour_utc(no_microseconds=True):\n if no_microseconds:\n return datetime.datetime.utcnow().replace(microsecond=0).time()\n else:\n return datetime.datetime.utcnow().time()","def time_now():\n ts = datetime.datetime.now().timetuple()\n return '{wday} {day} {month} {year} {hour}:{minute:0>2d}:{second:0>2d} UTC'.format(\n year=ts.tm_year, month=calendar.month_name[ts.tm_mon],\n day=ts.tm_mday, wday=calendar.day_name[ts.tm_wday],\n hour=ts.tm_hour, minute=ts.tm_min, second=ts.tm_sec)","def utcnow(cls):\n t = _time.time()\n return cls.utcfromtimestamp(t)","def FromNowUTC(cls):\n t = pytime.time()\n utcTime = pytime.gmtime(t)\n return cls.FromStructTime(utcTime).WithZone(zDirection=0)","def get_now_hour_utc(no_microseconds=True):\n if no_microseconds:\n return datetime.time.utcnow().replace(microsecond=0).time()\n else:\n return datetime.time.utcnow().time()","def curTimeMs():\n\treturn int((datetime.utcnow() - datetime(1970,1,1)).total_seconds() * 1000)","def get_current_unix_timestamp_ms():\r\n return int(datetime.timestamp(datetime.now())) * 1000","def get_current_timestamp():\n return int(round(time.time() * 1e3))","def _get_now():\n return datetime.now(tz=timezone.utc)","def get_now():\n return dt.datetime.now(dt.timezone.utc)","def now():\n return datetime.datetime.now(pytz.utc)","def _make_timestamp(self):\r\n\t\tlogger.debug(\"Get a timestamp\")\r\n\t\treturn time.mktime(datetime.today().timetuple())","def utcnow():\n utctime = datetime.datetime.utcnow()\n utcstamp = utctime.strftime(\"%Y-%m-%d %H:%M:%S\")\n return utcstamp","def now():\n return int(time.time() * 1000)","def timestamp():\n return round(datetime.datetime.utcnow().timestamp())","def now_utc() -> datetime:\n return datetime.now(timezone.utc)","def current_millis():\n return int(round(time.time() * 1000))","def utctime(self) -> datetime:\n return datetime.utcfromtimestamp(float(self.ns_since_epoch) / 1e9)","def timestamp(self):\n if self._tzinfo is None:\n s = self._mktime()\n return s + self.microsecond / 1e6\n else:\n return (self - _EPOCH).total_seconds()","def _now():\n return datetime.datetime.utcnow().replace(tzinfo=pytz.utc)","def get_timestamp():\n\n # Convert timestamp to int after multiply by 1000 to get millisecond timestamp in int.\n return int(time.time() * 1000)","def current_milli_time(self):\n return int(round(time.time() * 1000))","def getUnixTimeStamp():\n return calendar.timegm(datetime.utcnow().utctimetuple())","def utc_now():\n realtime = datetime.utcnow()\n realtime = pytz.utc.localize(realtime)\n return realtime","def get_utc_now():\n return datetime.datetime.utcnow().replace(tzinfo=pytz.timezone(\"UTC\"))","def __current_milli_time(self):\n\n return int(round(time.time() * 1000))","def utctime(stamp):\n return stamp + utc_offset","def datetime_utc_now() -> datetime:\n return datetime.now(timezone.utc)","def _Now():\n return datetime.datetime.utcnow()","def static_now():\n return datetime.datetime(2000, 9, 4).replace(tzinfo=timezone.utc)","def now():\n return datetime.datetime.utcnow()","def now_nanos():\n if now_nanos.sim_time == 0:\n now_nanos.sim_time += int(time.time() * 1000000000)\n else:\n now_nanos.sim_time += random.randint(MIN_TIME_DELTA_NANOS, MAX_TIME_DELTA_NANOS)\n\n return now_nanos.sim_time","def now():\n if os.sys.platform == 'win32':\n return time.clock() # best for windows? seems to give finer temporal resolution.\n else:\n return time.time() # best for Unix, others???","def now():\n return datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')","def timestamp(self):\n # this only returns second precision, which is why we don't use it\n #now = calendar.timegm(datetime.datetime.utcnow().utctimetuple())\n\n # this returns microsecond precision\n # http://bugs.python.org/msg180110\n epoch = datetime.datetime(1970, 1, 1)\n return (self - epoch).total_seconds()","def utc_now():\n return datetime.now(tz=timezone.utc)","def now():\n\n return rospy.Time.now().to_nsec()","def now():\n\treturn time.time() * 1000","def _time_ms(self, dt):\n if dt.tzinfo is None:\n dt = dt.replace(tzinfo=pytz.utc)\n return int((dt - self._EPOCH).total_seconds() * 1000)","def get_timestamp(self):\n return datetime.datetime.utcnow()","def now_dt(tz='UTC'):\n if tz != 'UTC':\n raise NotImplementedError()\n return datetime.datetime.utcnow().replace(tzinfo = pytz.utc)","def curr_time_millis():\n return 1000 * timeit.default_timer()","def get_timestamp_now():\n\n # local time as a time struct\n now = time.localtime()\n\n # convert time struct to seconds since epoch (timestamp)\n local = time.mktime(now)\n return str(local)","def createTimeStamp_Time():\r\n\r\n return str(datetime.now().strftime(\"%H%M%S\"))","def get_current_timestamp() -> int:\n # Python 3.3 introduced a :py:meth:`datetime.timestamp` method, but\n # for compatibility with Python 2, we have to do it the\n # old-fashioned way.\n # http://stackoverflow.com/q/2775864/\n return unix_timestamp(datetime.utcnow().timetuple())","def NOW() -> func_xltypes.XlDateTime:\n return utils.datetime_to_number(now())","def Timestamp():\n now = NowDateTime()\n return '%04d%02d%02d-%02d%02d%02d-%06d-%s' % (\n now.year,\n now.month,\n now.day,\n now.hour,\n now.minute,\n now.second,\n now.microsecond,\n time.tzname[0],\n )","def _get_current_epoch_time() -> float:\n return time.time()","def _getUTC(self, config = {} ):\n # Default implementation: get system local time\n return datetime.datetime.utcnow()","def epoch_time_now():\n return int(time.time())","def __get_unix_now(self):\n ms_now = int(time.time() * 10 ** 5)\n return hex(ms_now)[2:]","def get_timestamp() -> int:\n\n return int(time.time() * 1000)","def getutv(self):\n t = datetime.datetime.now()\n utc_seconds = (time.mktime(t.timetuple()))\n utc_seconds = int(utc_seconds * 1000)\n return str(utc_seconds)","def datetime_utcnow() -> datetime:\n return datetime.now(tz=pytz.timezone('UTC'))","def time_millis():\n\n return int(time.time() * 1000)","def currentTimestamp():\n return int(datetime.now().strftime('%s'))","def utcnow():\n return datetime.utcnow().replace(tzinfo=UTC)","def now_datetime():\n return datetime.utcnow().replace(tzinfo=timezone)","def tnow():\n return datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')","def db_datetime_utc():\n t = datetime.datetime.utcnow()\n return time.mktime(t.timetuple())","def current_time():\n\n return int(1000 * time())","def unix_time_millisecond(date):\r\n return unix_time(date, float=True) * 1e3","def _timestamp_now(self) -> str:\n date_now = datetime.utcnow().replace(tzinfo=timezone(\"UTC\"))\n if self._app_conf[\"aiscalator\"]:\n pst = timezone(self.app_config().timezone)\n else:\n pst = timezone('Europe/Paris')\n return date_now.astimezone(pst).strftime(\"%Y%m%d%H%M%S\")","def next_whole_second() -> datetime.datetime:\n return datetime.datetime.now(datetime.timezone.utc).replace(\n microsecond=0\n ) + datetime.timedelta(seconds=0)","def timestamp_normalized(self):\r\n if not self.timestamp:\r\n return None\r\n\r\n if isinstance(self.timestamp, (int, long)):\r\n return self.timestamp\r\n\r\n if isinstance(self.timestamp, timedelta):\r\n tmp = datetime.now() + self.timestamp\r\n else:\r\n tmp = self.timestamp\r\n\r\n return long(time.mktime(tmp.timetuple()) * 1e+6 + tmp.microsecond)","def timestamp(self) -> datetime.datetime.timestamp:\n timestamp = datetime.datetime.utcfromtimestamp(int(self._timestamp) / 1000)\n return timestamp","def get_current_time() -> int:\n float_time = time.time()\n return int(float_time * 1000) # Convert to ms and int","def now():\n now = datetime.datetime.now()\n return \"%04d-%02d-%02d %02d:%02d:%02d.%03d\" % ( now.year, now.month,now.day,\n now.hour,now.minute,now.second,int(now.microsecond/1e3))","def time_now():\n return datetime.datetime.now().time()","def timestamp():\n return datetime.utcnow().strftime(\"%F %T\")","def now(cls):\n return cls(2017, 4, 27,\n 13, 25, 46, 629282)","def makeTimeStamp():\n return datetime.datetime.now().strftime(\"%Y%m%d_%H%M%S\")","def utcnow() -> datetime.datetime:\n return datetime.datetime.utcnow().replace(tzinfo=pytz.UTC)","def current_timestamp(self) -> time:\n\n return time.time()","def utcTime():\r\n return calendar.timegm(time.gmtime())","def make_current():\n current = datetime.datetime.now()\n hour = '{:02d}'.format(current.hour)\n minute = '{:02d}'.format(current.minute)\n second = '{:02d}'.format(current.second)\n current_time = hour + minute + second\n return current_time","def _now():\n return datetime.now(timezone.utc).astimezone()","def get_timestamp(prev_ts=None):\n t = time.time()\n t = TimeStamp(*time.gmtime(t)[:5] + (t % 60,))\n if prev_ts is not None:\n t = t.laterThan(prev_ts)\n return t","def get_time_ms():\n return int(round(time.time() * 1000))","def currentUTC():\n return str(datetime.utcnow())","def time_in_millis(my_time=None):\n\n if my_time:\n t = my_time\n else:\n t = gmtime()\n\n return timegm(t)"],"string":"[\n \"def Now():\\n ut = (datetime.datetime.utcnow() - _EPOCH).total_seconds() / 86400.0\\n return Time(ut)\",\n \"def now() -> datetime:\\n now = datetime.now(tz=timezone.utc)\\n return now.replace(microsecond=now.microsecond - now.microsecond % 1000)\",\n \"def now_timestamp(unit: TimeUnit = TimeUnit.SECONDS) -> float:\\n return TimeHelper.to_timestamp(TimeHelper.now(), unit)\",\n \"def utcnow_ts():\\r\\n return calendar.timegm(utcnow().timetuple())\",\n \"def _create_timestamp():\\n return (datetime.utcnow() - datetime(1970,1,1)).total_seconds()\",\n \"def now_s():\\n return calendar.timegm(now_dt().utctimetuple())\",\n \"def getNowMilliseconds():\\n return (datetime.datetime.utcnow() - Common.epoch_).total_seconds() * 1000.0\",\n \"def get_now_utc(no_microseconds=True):\\n if no_microseconds:\\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\\n microsecond=0\\n )\\n else:\\n return pytz.utc.localize(datetime.datetime.utcnow())\",\n \"def get_now_utc(no_microseconds=True):\\n if no_microseconds:\\n return pytz.utc.localize(datetime.datetime.utcnow()).replace(\\n microsecond=0\\n )\\n else:\\n return pytz.utc.localize(datetime.datetime.utcnow())\",\n \"def now():\\n return utcfromtimestamp(time.time())\",\n \"def utc_millisecond_timestamp():\\n return __date_to_millisecond_ts(utc())\",\n \"def local_timestamp():\\n # type: () -> int\\n now = datetime.utcnow()\\n timestamp_in_seconds = calendar.timegm(now.timetuple()) + (now.microsecond / 1e6)\\n timestamp_in_milliseconds = int(timestamp_in_seconds * 1000)\\n return timestamp_in_milliseconds\",\n \"def nowUTC():\\n return datetime.datetime.now(pytz.utc)\",\n \"def _nowms():\\n return int(time.time() * 1000)\",\n \"def default_timestamp():\\n date = datetime.datetime.now().replace(microsecond=0)\\n return date\",\n \"def current_time_millis():\\n return int(round(time.time() * 1000))\",\n \"def now():\\n return int(datetime.datetime.now().strftime(\\\"%s\\\")) * 1000\",\n \"def timestamp(millis=False):\\n return int(round(time.time() * (millis and 1000 or 1)))\",\n \"def tstamp_now(self):\\n return self.tstamp(datetime.datetime.now(tz))\",\n \"def get_now_hour_utc(no_microseconds=True):\\n if no_microseconds:\\n return datetime.datetime.utcnow().replace(microsecond=0).time()\\n else:\\n return datetime.datetime.utcnow().time()\",\n \"def time_now():\\n ts = datetime.datetime.now().timetuple()\\n return '{wday} {day} {month} {year} {hour}:{minute:0>2d}:{second:0>2d} UTC'.format(\\n year=ts.tm_year, month=calendar.month_name[ts.tm_mon],\\n day=ts.tm_mday, wday=calendar.day_name[ts.tm_wday],\\n hour=ts.tm_hour, minute=ts.tm_min, second=ts.tm_sec)\",\n \"def utcnow(cls):\\n t = _time.time()\\n return cls.utcfromtimestamp(t)\",\n \"def FromNowUTC(cls):\\n t = pytime.time()\\n utcTime = pytime.gmtime(t)\\n return cls.FromStructTime(utcTime).WithZone(zDirection=0)\",\n \"def get_now_hour_utc(no_microseconds=True):\\n if no_microseconds:\\n return datetime.time.utcnow().replace(microsecond=0).time()\\n else:\\n return datetime.time.utcnow().time()\",\n \"def curTimeMs():\\n\\treturn int((datetime.utcnow() - datetime(1970,1,1)).total_seconds() * 1000)\",\n \"def get_current_unix_timestamp_ms():\\r\\n return int(datetime.timestamp(datetime.now())) * 1000\",\n \"def get_current_timestamp():\\n return int(round(time.time() * 1e3))\",\n \"def _get_now():\\n return datetime.now(tz=timezone.utc)\",\n \"def get_now():\\n return dt.datetime.now(dt.timezone.utc)\",\n \"def now():\\n return datetime.datetime.now(pytz.utc)\",\n \"def _make_timestamp(self):\\r\\n\\t\\tlogger.debug(\\\"Get a timestamp\\\")\\r\\n\\t\\treturn time.mktime(datetime.today().timetuple())\",\n \"def utcnow():\\n utctime = datetime.datetime.utcnow()\\n utcstamp = utctime.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n return utcstamp\",\n \"def now():\\n return int(time.time() * 1000)\",\n \"def timestamp():\\n return round(datetime.datetime.utcnow().timestamp())\",\n \"def now_utc() -> datetime:\\n return datetime.now(timezone.utc)\",\n \"def current_millis():\\n return int(round(time.time() * 1000))\",\n \"def utctime(self) -> datetime:\\n return datetime.utcfromtimestamp(float(self.ns_since_epoch) / 1e9)\",\n \"def timestamp(self):\\n if self._tzinfo is None:\\n s = self._mktime()\\n return s + self.microsecond / 1e6\\n else:\\n return (self - _EPOCH).total_seconds()\",\n \"def _now():\\n return datetime.datetime.utcnow().replace(tzinfo=pytz.utc)\",\n \"def get_timestamp():\\n\\n # Convert timestamp to int after multiply by 1000 to get millisecond timestamp in int.\\n return int(time.time() * 1000)\",\n \"def current_milli_time(self):\\n return int(round(time.time() * 1000))\",\n \"def getUnixTimeStamp():\\n return calendar.timegm(datetime.utcnow().utctimetuple())\",\n \"def utc_now():\\n realtime = datetime.utcnow()\\n realtime = pytz.utc.localize(realtime)\\n return realtime\",\n \"def get_utc_now():\\n return datetime.datetime.utcnow().replace(tzinfo=pytz.timezone(\\\"UTC\\\"))\",\n \"def __current_milli_time(self):\\n\\n return int(round(time.time() * 1000))\",\n \"def utctime(stamp):\\n return stamp + utc_offset\",\n \"def datetime_utc_now() -> datetime:\\n return datetime.now(timezone.utc)\",\n \"def _Now():\\n return datetime.datetime.utcnow()\",\n \"def static_now():\\n return datetime.datetime(2000, 9, 4).replace(tzinfo=timezone.utc)\",\n \"def now():\\n return datetime.datetime.utcnow()\",\n \"def now_nanos():\\n if now_nanos.sim_time == 0:\\n now_nanos.sim_time += int(time.time() * 1000000000)\\n else:\\n now_nanos.sim_time += random.randint(MIN_TIME_DELTA_NANOS, MAX_TIME_DELTA_NANOS)\\n\\n return now_nanos.sim_time\",\n \"def now():\\n if os.sys.platform == 'win32':\\n return time.clock() # best for windows? seems to give finer temporal resolution.\\n else:\\n return time.time() # best for Unix, others???\",\n \"def now():\\n return datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')\",\n \"def timestamp(self):\\n # this only returns second precision, which is why we don't use it\\n #now = calendar.timegm(datetime.datetime.utcnow().utctimetuple())\\n\\n # this returns microsecond precision\\n # http://bugs.python.org/msg180110\\n epoch = datetime.datetime(1970, 1, 1)\\n return (self - epoch).total_seconds()\",\n \"def utc_now():\\n return datetime.now(tz=timezone.utc)\",\n \"def now():\\n\\n return rospy.Time.now().to_nsec()\",\n \"def now():\\n\\treturn time.time() * 1000\",\n \"def _time_ms(self, dt):\\n if dt.tzinfo is None:\\n dt = dt.replace(tzinfo=pytz.utc)\\n return int((dt - self._EPOCH).total_seconds() * 1000)\",\n \"def get_timestamp(self):\\n return datetime.datetime.utcnow()\",\n \"def now_dt(tz='UTC'):\\n if tz != 'UTC':\\n raise NotImplementedError()\\n return datetime.datetime.utcnow().replace(tzinfo = pytz.utc)\",\n \"def curr_time_millis():\\n return 1000 * timeit.default_timer()\",\n \"def get_timestamp_now():\\n\\n # local time as a time struct\\n now = time.localtime()\\n\\n # convert time struct to seconds since epoch (timestamp)\\n local = time.mktime(now)\\n return str(local)\",\n \"def createTimeStamp_Time():\\r\\n\\r\\n return str(datetime.now().strftime(\\\"%H%M%S\\\"))\",\n \"def get_current_timestamp() -> int:\\n # Python 3.3 introduced a :py:meth:`datetime.timestamp` method, but\\n # for compatibility with Python 2, we have to do it the\\n # old-fashioned way.\\n # http://stackoverflow.com/q/2775864/\\n return unix_timestamp(datetime.utcnow().timetuple())\",\n \"def NOW() -> func_xltypes.XlDateTime:\\n return utils.datetime_to_number(now())\",\n \"def Timestamp():\\n now = NowDateTime()\\n return '%04d%02d%02d-%02d%02d%02d-%06d-%s' % (\\n now.year,\\n now.month,\\n now.day,\\n now.hour,\\n now.minute,\\n now.second,\\n now.microsecond,\\n time.tzname[0],\\n )\",\n \"def _get_current_epoch_time() -> float:\\n return time.time()\",\n \"def _getUTC(self, config = {} ):\\n # Default implementation: get system local time\\n return datetime.datetime.utcnow()\",\n \"def epoch_time_now():\\n return int(time.time())\",\n \"def __get_unix_now(self):\\n ms_now = int(time.time() * 10 ** 5)\\n return hex(ms_now)[2:]\",\n \"def get_timestamp() -> int:\\n\\n return int(time.time() * 1000)\",\n \"def getutv(self):\\n t = datetime.datetime.now()\\n utc_seconds = (time.mktime(t.timetuple()))\\n utc_seconds = int(utc_seconds * 1000)\\n return str(utc_seconds)\",\n \"def datetime_utcnow() -> datetime:\\n return datetime.now(tz=pytz.timezone('UTC'))\",\n \"def time_millis():\\n\\n return int(time.time() * 1000)\",\n \"def currentTimestamp():\\n return int(datetime.now().strftime('%s'))\",\n \"def utcnow():\\n return datetime.utcnow().replace(tzinfo=UTC)\",\n \"def now_datetime():\\n return datetime.utcnow().replace(tzinfo=timezone)\",\n \"def tnow():\\n return datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')\",\n \"def db_datetime_utc():\\n t = datetime.datetime.utcnow()\\n return time.mktime(t.timetuple())\",\n \"def current_time():\\n\\n return int(1000 * time())\",\n \"def unix_time_millisecond(date):\\r\\n return unix_time(date, float=True) * 1e3\",\n \"def _timestamp_now(self) -> str:\\n date_now = datetime.utcnow().replace(tzinfo=timezone(\\\"UTC\\\"))\\n if self._app_conf[\\\"aiscalator\\\"]:\\n pst = timezone(self.app_config().timezone)\\n else:\\n pst = timezone('Europe/Paris')\\n return date_now.astimezone(pst).strftime(\\\"%Y%m%d%H%M%S\\\")\",\n \"def next_whole_second() -> datetime.datetime:\\n return datetime.datetime.now(datetime.timezone.utc).replace(\\n microsecond=0\\n ) + datetime.timedelta(seconds=0)\",\n \"def timestamp_normalized(self):\\r\\n if not self.timestamp:\\r\\n return None\\r\\n\\r\\n if isinstance(self.timestamp, (int, long)):\\r\\n return self.timestamp\\r\\n\\r\\n if isinstance(self.timestamp, timedelta):\\r\\n tmp = datetime.now() + self.timestamp\\r\\n else:\\r\\n tmp = self.timestamp\\r\\n\\r\\n return long(time.mktime(tmp.timetuple()) * 1e+6 + tmp.microsecond)\",\n \"def timestamp(self) -> datetime.datetime.timestamp:\\n timestamp = datetime.datetime.utcfromtimestamp(int(self._timestamp) / 1000)\\n return timestamp\",\n \"def get_current_time() -> int:\\n float_time = time.time()\\n return int(float_time * 1000) # Convert to ms and int\",\n \"def now():\\n now = datetime.datetime.now()\\n return \\\"%04d-%02d-%02d %02d:%02d:%02d.%03d\\\" % ( now.year, now.month,now.day,\\n now.hour,now.minute,now.second,int(now.microsecond/1e3))\",\n \"def time_now():\\n return datetime.datetime.now().time()\",\n \"def timestamp():\\n return datetime.utcnow().strftime(\\\"%F %T\\\")\",\n \"def now(cls):\\n return cls(2017, 4, 27,\\n 13, 25, 46, 629282)\",\n \"def makeTimeStamp():\\n return datetime.datetime.now().strftime(\\\"%Y%m%d_%H%M%S\\\")\",\n \"def utcnow() -> datetime.datetime:\\n return datetime.datetime.utcnow().replace(tzinfo=pytz.UTC)\",\n \"def current_timestamp(self) -> time:\\n\\n return time.time()\",\n \"def utcTime():\\r\\n return calendar.timegm(time.gmtime())\",\n \"def make_current():\\n current = datetime.datetime.now()\\n hour = '{:02d}'.format(current.hour)\\n minute = '{:02d}'.format(current.minute)\\n second = '{:02d}'.format(current.second)\\n current_time = hour + minute + second\\n return current_time\",\n \"def _now():\\n return datetime.now(timezone.utc).astimezone()\",\n \"def get_timestamp(prev_ts=None):\\n t = time.time()\\n t = TimeStamp(*time.gmtime(t)[:5] + (t % 60,))\\n if prev_ts is not None:\\n t = t.laterThan(prev_ts)\\n return t\",\n \"def get_time_ms():\\n return int(round(time.time() * 1000))\",\n \"def currentUTC():\\n return str(datetime.utcnow())\",\n \"def time_in_millis(my_time=None):\\n\\n if my_time:\\n t = my_time\\n else:\\n t = gmtime()\\n\\n return timegm(t)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7358585","0.73144686","0.73085713","0.7295754","0.72463673","0.719578","0.71388984","0.71132016","0.71132016","0.7087358","0.70538455","0.70202845","0.69747436","0.69600034","0.6942168","0.6916312","0.69006324","0.68955755","0.68503773","0.68242997","0.6822988","0.6818244","0.6805908","0.67947847","0.6773551","0.6769527","0.6767089","0.67489755","0.6718834","0.67101693","0.6689829","0.6678695","0.66737866","0.6656299","0.66535026","0.6644845","0.6639327","0.6638059","0.66256","0.6617197","0.66143227","0.6581892","0.6562127","0.6561457","0.65564716","0.6554361","0.65341157","0.6532169","0.6501668","0.64981943","0.6493745","0.64728004","0.64719737","0.64528036","0.64518553","0.644932","0.6442448","0.6421428","0.6410691","0.6396113","0.63953835","0.63899034","0.6387215","0.637021","0.6369908","0.63590294","0.6352483","0.63327473","0.63303906","0.6328427","0.6325015","0.63194877","0.63149744","0.6313163","0.62830836","0.62784976","0.6276634","0.62636715","0.6261033","0.6256296","0.62550837","0.62476665","0.6240902","0.6228009","0.62270856","0.6221706","0.62190807","0.6203285","0.6199099","0.61981076","0.6188625","0.6188205","0.61865675","0.61856","0.6183311","0.6181995","0.6176751","0.61656374","0.61638","0.6157954"],"string":"[\n \"0.7358585\",\n \"0.73144686\",\n \"0.73085713\",\n \"0.7295754\",\n \"0.72463673\",\n \"0.719578\",\n \"0.71388984\",\n \"0.71132016\",\n \"0.71132016\",\n \"0.7087358\",\n \"0.70538455\",\n \"0.70202845\",\n \"0.69747436\",\n \"0.69600034\",\n \"0.6942168\",\n \"0.6916312\",\n \"0.69006324\",\n \"0.68955755\",\n \"0.68503773\",\n \"0.68242997\",\n \"0.6822988\",\n \"0.6818244\",\n \"0.6805908\",\n \"0.67947847\",\n \"0.6773551\",\n \"0.6769527\",\n \"0.6767089\",\n \"0.67489755\",\n \"0.6718834\",\n \"0.67101693\",\n \"0.6689829\",\n \"0.6678695\",\n \"0.66737866\",\n \"0.6656299\",\n \"0.66535026\",\n \"0.6644845\",\n \"0.6639327\",\n \"0.6638059\",\n \"0.66256\",\n \"0.6617197\",\n \"0.66143227\",\n \"0.6581892\",\n \"0.6562127\",\n \"0.6561457\",\n \"0.65564716\",\n \"0.6554361\",\n \"0.65341157\",\n \"0.6532169\",\n \"0.6501668\",\n \"0.64981943\",\n \"0.6493745\",\n \"0.64728004\",\n \"0.64719737\",\n \"0.64528036\",\n \"0.64518553\",\n \"0.644932\",\n \"0.6442448\",\n \"0.6421428\",\n \"0.6410691\",\n \"0.6396113\",\n \"0.63953835\",\n \"0.63899034\",\n \"0.6387215\",\n \"0.637021\",\n \"0.6369908\",\n \"0.63590294\",\n \"0.6352483\",\n \"0.63327473\",\n \"0.63303906\",\n \"0.6328427\",\n \"0.6325015\",\n \"0.63194877\",\n \"0.63149744\",\n \"0.6313163\",\n \"0.62830836\",\n \"0.62784976\",\n \"0.6276634\",\n \"0.62636715\",\n \"0.6261033\",\n \"0.6256296\",\n \"0.62550837\",\n \"0.62476665\",\n \"0.6240902\",\n \"0.6228009\",\n \"0.62270856\",\n \"0.6221706\",\n \"0.62190807\",\n \"0.6203285\",\n \"0.6199099\",\n \"0.61981076\",\n \"0.6188625\",\n \"0.6188205\",\n \"0.61865675\",\n \"0.61856\",\n \"0.6183311\",\n \"0.6181995\",\n \"0.6176751\",\n \"0.61656374\",\n \"0.61638\",\n \"0.6157954\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7725665"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":12893,"cells":{"query":{"kind":"string","value":"Convert to the string in whiltespaceseparated tokens Addhoc addition."},"document":{"kind":"string","value":"def convert_pr_wvi_to_string(pr_wvi, nlu_t, nlu_wp_t, wp_to_wh_index, nlu):\r\n pr_wv_str_wp = [] # word-piece version\r\n pr_wv_str = []\r\n for b, pr_wvi1 in enumerate(pr_wvi):\r\n pr_wv_str_wp1 = []\r\n pr_wv_str1 = []\r\n wp_to_wh_index1 = wp_to_wh_index[b]\r\n nlu_wp_t1 = nlu_wp_t[b]\r\n nlu_t1 = nlu_t[b]\r\n\r\n for i_wn, pr_wvi11 in enumerate(pr_wvi1):\r\n st_idx, ed_idx = pr_wvi11\r\n\r\n # Ad-hoc modification of ed_idx to deal with wp-tokenization effect.\r\n # e.g.) to convert \"butler cc (\" ->\"butler cc (ks)\" (dev set 1st question).\r\n pr_wv_str_wp11 = nlu_wp_t1[st_idx:ed_idx+1]\r\n pr_wv_str_wp1.append(pr_wv_str_wp11)\r\n\r\n st_wh_idx = wp_to_wh_index1[st_idx]\r\n ed_wh_idx = wp_to_wh_index1[ed_idx]\r\n pr_wv_str11 = nlu_t1[st_wh_idx:ed_wh_idx+1]\r\n\r\n pr_wv_str1.append(pr_wv_str11)\r\n\r\n pr_wv_str_wp.append(pr_wv_str_wp1)\r\n pr_wv_str.append(pr_wv_str1)\r\n\r\n return pr_wv_str, pr_wv_str_wp"},"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_spaces(text):\n return \" \".join(text)","def _remove_extra_whitespaces(self, text: str) -> str:\n return re.sub(\" +\", \" \", text)","def wrapspace(text, token):\n\n # Wildcards have no whitespace. Need special case since * is also multiply which does have whitespace.\n if token in [\"*\"] and (not text or text.endswith((\" \", \"(\"))):\n return token\n\n # Operator whitespace\n if Token.isoperator(token) or Token.islogicseparator(token) or token.lower() in [\"in\"]:\n return f\" {token} \" if not text.endswith(\" \") else f\"{token} \"\n\n # Comma whitespace\n if Token.isseparator(token):\n return f\"{token} \"\n\n # No whitespace if any of the following is True\n if not text or text.endswith((\" \", \"(\", \"[\")) or token in [\"(\", \"[\", \")\", \"]\"] or token.startswith(\".\"):\n return token\n\n # Default is to add leading whitespace\n return f\" {token}\"","def add_special_tokens_single_sentence(self, token_ids):\r\n return [self.token_to_id(self.cls_token)] + token_ids + [self.token_to_id(self.sep_token)]","def _build_add(self) -> str:\n return dedent(\n \"\"\"\n @SP\n M=M-1\n A=M\n D=M\n @SP\n M=M-1\n A=M\n M=M+D\n @SP\n M=M+1\n \"\"\"\n )","def add_special_tokens_single_sentence(self, token_ids):\n return [self.cls_token_id] + token_ids + [self.sep_token_id]","def join(self, tokens):\n if self.chars:\n joiner = ''\n else:\n joiner = ' '\n return joiner.join(tokens)","def sep(s):\n return ' '+s if s else s","def concatenate_processed_text(self):\n\n\n\t\tconcatenated_text = \"\"\n\t\tfor line in self.processed_text:\n\t\t\tconcatenated_text += \" \".join(line) + \" \"\n\n\n\t\t# Remove the trailing space character from the concatenated string\n\t\t# of words.\n\t\tconcatenated_text = concatenated_text[:-1]\n\n\t\tself.concatenated_text = concatenated_text","def get_insert_token(self, word):\n # Insert word choose\n return ''.join([word] * 2)","def _build_and(self) -> str:\n return dedent(\n \"\"\"\n @SP\n M=M-1\n A=M\n D=M\n @SP\n M=M-1\n A=M\n M=M&D\n @SP\n M=M+1\n \"\"\"\n )","def camma_plus(s):\n return s+\",\"","def __str__(self):\n if self._tokens == '*' or self._tokens == '':\n return self._tokens\n self.compact()\n return \"\".join(str(s[0])+s[1] for s in self._tokens)","def add_special_tokens_single_sentence(self, token_ids):\n sep = [self._convert_token_to_id(self.sep_token)]\n cls = [self._convert_token_to_id(self.cls_token)]\n return token_ids + sep + cls","def quote_plus(s, safe='', encoding=None, errors=None):\n if ' ' in s:\n s = quote(s, safe + ' ', encoding, errors)\n return s.replace(' ', '+')\n return quote(s, safe, encoding, errors)","def concat_text(self, elem):\n\n s = u\" \".join([ frag.strip() for frag in elem.itertext() if re.search(\"\\S\", frag) ]) \n return re.sub(\" (\\W )\", \"\\\\1\", s)","def gen_parse_op_text(conversation):\n ret_text = \"\"\n conv_parse_ops = conversation.parse_operation\n for i in range(1, len(conv_parse_ops)):\n ret_text += conv_parse_ops[i] + \" \"\n ret_text = ret_text[:-1]\n return ret_text","def __radd__(self, other):\n return Token(\n other + self.text, self.position - len(other), self.category)","def add_separator(self, structure, word, debug=False):\n word_segmented = list(word)\n char = 0\n forward = 0\n while char < len(structure) - 1:\n if structure[char] == '-':\n word_segmented.insert(char + forward, '-')\n elif structure[char] == 'T':\n forward += 1 # moving one forward because T is mapped to two characters\n char += 1\n\n if debug:\n print(structure, word, word_segmented, ''.join(word_segmented))\n\n return ''.join(word_segmented)","def add_tokens(self, tokens):\n self.result.extend([d for d in tokens])","def str (self, max_len_first, max_len_following=0) :\r\n\r\n\t\t## This version indents continuation lines by 1 space\r\n\t\tif not max_len_following == 0 :\r\n\t\t\tmax_len_following -= 1\r\n\t\t\r\n\t\tresult = tokenizer.join_tokens(self.tokens, max_len_first, max_len_following)\r\n\t\tresult[1:] = [ (\" \" + r) for r in result[1:] ]\r\n\r\n\t\treturn [result]","def to_whitespace(self, empty=False, strip_nl=False, strip_comments=False):\n if strip_nl and self.type == tokenize.NL:\n self.string = \"\"\n return\n if strip_comments and self.type == tokenize.COMMENT:\n self.string = \"\"\n return\n if self.type in ignored_types_set:\n return\n if empty:\n self.string = \"\"\n else:\n self.string = \" \" * len(self.token_tuple[1])","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 tokenized(self, text):\n return self.tokenizer.encode_plus(text,\n max_length=512,\n pad_to_max_length=True,\n truncation=True)[\"input_ids\"]","def insert_spaces(word):\n new_word = \"\"\n for c in word:\n new_word += c + \" \" \n return new_word","def reduce_spaces(tweet):\r\n text = tweet.strip()\r\n text = \" \".join(text.split())\r\n return re.sub(' +', ' ', text)","def concat_text(text):\n textout = \" \".join(text)\n return textout","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__(self, other):\n space = '' if other.type == 'punctuation' else ' '\n new = Word('0.0', '0.0', self.word + space + other.word, self.type)\n new.start = self.start\n new.end = other.end\n return new","def convert_spaces(msg_list):\n new_list = []\n for str in msg_list:\n new_list.append(str.replace(' ', '+'))\n return (new_list)","def get_orion_space_string(self) -> str:","def preproc_user_input(txt, model):\r\n txt = pre_process(txt)\r\n txt_tokenized = [word for word in txt.split(\" \") if word in model.wv.vocab]\r\n return \" \".join(txt_tokenized)","def token_chain(text, filters):\n if filters is None:\n return text\n\n sb = \"\"\n for token in RegexFilters.WHITESPACE.split(text):\n if not classifier_options.is_special_class_word(token):\n token = Filters.string_chain(token, filters)\n\n sb += token + \" \"\n\n return sb","def andify(things: list):\n if len(things) < 1:\n return \"\"\n return (f'{\", \".join(things[:-1])}' +\n f'{\", and \" if len(things) > 2 else (\" and \" if len(things) > 1 else \"\")}' +\n f'{things[-1]}')","def remove_extra_space(text):\n return re.sub(' +', ' ', text)","def word_join(self, words):\n return \" \".join(words)","def _concat(self, *args, **kwargs):\n values = list(args)\n output = []\n for value in values:\n if not isinstance(value, (str, basestring)):\n value = unicode(value)\n else:\n value = unicode(value)\n value = value.strip()\n output.append(value)\n output = kwargs[\"delimiter\"].join(output)\n output = unicode(output)\n return output","def simplify(text, whitespace=string.whitespace, delete=\"\"):\n result = []\n word = \"\"\n for char in text:\n if char in delete:\n continue\n elif char in whitespace:\n if word:\n result.append(word)\n word = \"\"\n else:\n word += char\n if word:\n result.append(word)\n return \" \".join(result)","def _add_to_expression(self, item):\n addition = ' {%s} ' % item.text()\n expression = self.ui.expression\n pos = expression.cursorPosition()\n text = str(expression.displayText())\n expression.setText(text[:pos] + addition + text[pos:])","def comma_for_space(x):\n x = strip_stoich_wrapper(x)\n x = x.replace(\" \", \",\")\n return x","def whisper(*text: str, sep=' '):\n return f'<amazon:effect name=”whispered”>{sep.join(text)}</amazon:effect>'","def reformat_search_for_spaces(self):\r\n self.yt_search_key = self.yt_search_key.rstrip().replace(' ', '+')","def _despace(statement):\n return re.sub(r' +', ' ', statement)","def replace_spaces_with_pluses(self, sample):\r\n changed = list(sample)\r\n for i, c in enumerate(changed):\r\n if(c == ' ' or c ==' ' or c ==' ' or c=='\\n' or c=='\\n\\n'):\r\n changed[i] = '+'\r\n return ''.join(changed)","def _preprocess(self, tagged: List[Tuple]) -> str:\n ori = \" \".join([tag[0] for tag in tagged if tag[1] != \"SPACE\"])\n sent = \" \".join([tag[1] for tag in tagged if tag[1] != \"SPACE\"])\n sent = sent.replace(\"-LRB-\", \"(\")\n sent = sent.replace(\"-RRB-\", \")\")\n return sent, ori","def words_string(self):\n return ' '.join(self.words).replace(' - ', '')","def concat_tokens(tokens, token_filter=None):\n # The following assertion is to aid in debugging a common but\n # difficult-to-pinpoint programming mistake.\n assert not isinstance(tokens, (str, unicode)), (\n 'concat_tokens() was passed a string rather than a sequence of tokens.\\n\\n tokens[:100]:\\n %s'\n % repr(tokens[:100])\n )\n try:\n if token_filter:\n return ''.join([token.xml for token in tokens if isinstance(token, token_filter)])\n else:\n return ''.join([token.xml for token in tokens])\n except AttributeError, value:\n raise RexlibError('An AttributeError was raised in concat_tokens(): %s' % value)","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 _concatenate_instance(\n self,\n emotion: str,\n target_utterance: str,\n evidence_utterance: str,\n conversation_history: str,\n ) -> str:\n concatenated_text = (\n \" \"\n + emotion\n + \" <SEP> \"\n + target_utterance\n + \" <SEP> \"\n + evidence_utterance\n + \" <SEP> \"\n + conversation_history\n )\n\n return concatenated_text","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 pre_process(text: str) -> str:\n text = text.replace('--', '-')\n space_right = '!?:;,.-()*+-/<=>@^_'\n space_both = '-()*+-/<=>@^_'\n\n for punct in space_right:\n text = text.replace(punct, punct + ' ')\n for punct in space_both:\n text = text.replace(punct, ' ' + punct + ' ')\n\n # remove extra space\n text = re.sub(r' +', ' ', text)\n return text","def __add(thiselement, char):\n if thiselement == None:\n return char\n return thiselement + char","def remove_extra_space(text):\n text = \" \".join(text.split())\n return text","def __add__(self, other):\n if type(other) == str:\n return str(self) + other","def __add__(self, chars):\n newdata = list(self.data) + list(str(chars))\n return MutableString(''.join(newdata))","def _commandline_join(self, tokens):\r\n commands = filter(None, map(str, tokens))\r\n return self._command_delimiter.join(commands).strip()","def _commandline_join(self, tokens):\r\n commands = filter(None, map(str, tokens))\r\n return self._command_delimiter.join(commands).strip()","def _commandline_join(self, tokens):\r\n commands = filter(None, map(str, tokens))\r\n return self._command_delimiter.join(commands).strip()","def convert_to_string(tokens):\n\n return ' '.join(tokens)","def _add_text(self, elem):\n words = WORD_SEPARATORS.split(elem.string.lower())\n for word in words:\n word = word.strip()\n if word in self._ignored_words:\n continue\n self._curr_words.append((self.crawler.word_id(word), self._font_size))","def concatenate_items(items, conjunction='and'):\n text = ''\n if not items:\n text = ''\n elif len(items) == 1:\n text = items[0]\n elif len(items) == 2:\n text = '{} {} {}'.format(items[0], conjunction, items[1])\n else:\n text = ', '.join(items[:-1])\n text += ', {} {}'.format(conjunction, items[-1])\n return text","def merge_wv_t1_eng(where_str_tokens, NLq):\r\n nlq = NLq.lower()\r\n where_str_tokens = [tok.lower() for tok in where_str_tokens]\r\n alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789$'\r\n special = {'-LRB-': '(',\r\n '-RRB-': ')',\r\n '-LSB-': '[',\r\n '-RSB-': ']',\r\n '``': '\"',\r\n '\\'\\'': '\"',\r\n }\r\n # '--': '\\u2013'} # this generate error for test 5661 case.\r\n ret = ''\r\n double_quote_appear = 0\r\n for raw_w_token in where_str_tokens:\r\n # if '' (empty string) of None, continue\r\n if not raw_w_token:\r\n continue\r\n\r\n # Change the special characters\r\n w_token = special.get(raw_w_token, raw_w_token) # maybe necessary for some case?\r\n\r\n # check the double quote\r\n if w_token == '\"':\r\n double_quote_appear = 1 - double_quote_appear\r\n\r\n # Check whether ret is empty. ret is selected where condition.\r\n if len(ret) == 0:\r\n pass\r\n # Check blank character.\r\n elif len(ret) > 0 and ret + ' ' + w_token in nlq:\r\n # Pad ' ' if ret + ' ' is part of nlq.\r\n ret = ret + ' '\r\n\r\n elif len(ret) > 0 and ret + w_token in nlq:\r\n pass # already in good form. Later, ret + w_token will performed.\r\n\r\n # Below for unnatural question I guess. Is it likely to appear?\r\n elif w_token == '\"':\r\n if double_quote_appear:\r\n ret = ret + ' ' # pad blank line between next token when \" because in this case, it is of closing apperas\r\n # for the case of opening, no blank line.\r\n\r\n elif w_token[0] not in alphabet:\r\n pass # non alphabet one does not pad blank line.\r\n\r\n # when previous character is the special case.\r\n elif (ret[-1] not in ['(', '/', '\\u2013', '#', '$', '&']) and (ret[-1] != '\"' or not double_quote_appear):\r\n ret = ret + ' '\r\n ret = ret + w_token\r\n\r\n return ret.strip()","def encode(inp, typee, dictt):\r\n inp_str = inp.decode(\"utf-8\")\r\n if \"x\" in typee:\r\n tokens = inp_str.split() + [\"</s>\"]\r\n else:\r\n tokens = [\"<s>\"] + inp_str.split() + [\"</s>\"]\r\n\r\n x = [dictt.get(t, dictt[\"<unk>\"]) for t in tokens]\r\n return x","def joined_parameter(*values: str) -> str:\n return \"+\".join(values)","def edit_tokens (input_words):\n length = len(input_words)\n for i, w in enumerate(input_words):\n if (w == \"{\"):\n if (i+2 < length):\n if (input_words[i+2] == \"}\"):\n input_words[i:i+3] = [''.join(input_words[i:i+3])]\n return input_words","def _add_val(self, val):\n if not val or val == \"{}\":\n return ''\n val = self._strip_braces(val)\n val = self._strip_quotes(val)\n val = self._strip_braces(val)\n val = self._string_subst(val)\n return val","def removeExtraSpaces(self, words):\n\t\treturn re.sub(r'\\s+', ' ', words.strip()).strip()","def remocion_de_espacios(self, texto):\n \n texto = re.sub(' +', ' ', texto)\n return texto.strip()","def tokenize(eq):\n\n def push(token):\n if token != \"\":\n if token[0].isdigit():\n tokens.append(int(token))\n else:\n tokens.append(token)\n\n tokens = []\n token = \"\"\n\n for t in eq:\n if t == \" \":\n push(token)\n token = \"\"\n if t == \"+\" or t == \"*\" or t == \"(\" or t == \")\":\n push(token)\n push(t)\n token = \"\"\n elif t.isdigit():\n token += t\n\n push(token)\n return tokens","def add_padding(self, text):\n\n for word in text.split(' '):\n # 5 character blocks added straight\n if len(word) == 5:\n self.output += word + ' '\n # calling the helper method to fill the blocks\n elif len(word) < 5:\n self._helper(word)\n # split the block up into 5 letter chunks\n elif len(word) > 5:\n block = ''\n for letter in word:\n block += letter\n if len(block) == 5:\n # append the chunk to output\n self.output += block + ' '\n block = ''\n self._helper(block)\n\n return self.output.upper()","def add_special_tokens_sentences_pair(self, token_ids_0, token_ids_1):\r\n sep = [self.token_to_id(self.sep_token)]\r\n cls = [self.token_to_id(self.cls_token)]\r\n return cls + token_ids_0 + sep + sep + token_ids_1 + sep","def add_special_tokens_sentences_pair(self, token_ids_0, token_ids_1):\n sep = [self.sep_token_id]\n cls = [self.cls_token_id]\n return cls + token_ids_0 + sep + token_ids_1 + sep","def add(text):\n orig = dispb[\"text\"]\n new = orig + text\n ops = [\"+\",\"-\",\"*\",\"/\"]\n # conditions\n # length 21\n if len(new) > 21:\n dispb[\"text\"] = orig\n return 0\n \n # one calc at a time\n if len(orig) > 0:\n if (orig[-1] in ops) & (text in ops):\n dispb[\"text\"] = orig\n return 0\n\n dispb[\"text\"] = new\n return 0","def remove_space(user_inputs):\r\n return user_inputs.replace(\" \", \"\")","def print_new_word(self,word):\n new_word = ''\n for i in word:\n new_word+= i\n return new_word","def punctuation(self, value):\n value = re.sub('_', ' ', value)\n value = re.sub(',', ' ', value)\n value = re.sub('\\'', ' ', value)\n value = re.sub(r'[^\\w\\s]','', value)\n value = re.sub(r'\\s+',' ',value)\n return value","def join_with_and(values, last_word: str = 'and') -> str:\n valuesList = list(values)\n length = len(valuesList)\n\n # value1, value2, value3 and value4\n if length > 2:\n return '{} {} {}'.format(', '.join(valuesList[:-1]), last_word, valuesList[-1])\n # value1 and value2\n elif length == 2:\n return '{} {} {}'.format(valuesList[0], last_word, valuesList[1])\n # value 1\n elif length == 1:\n return valuesList[0]\n # Empty\n return ''","def simple_tokeniser(sent):\n sent = re_tok_apos.sub(r\"\\1 's\", sent)\n sent = re_tok_mw_punc.sub(r\"\\1 \\2\", sent)\n sent = re_tok_punc.sub(r\" \\1 \", sent).replace('-', ' - ')\n sent = re_tok_punc.sub(r\" \\1 \", sent)\n sent = re_tok_mult_space.sub(' ', sent)\n return sent.lower().split()","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 smart_add(\n name = None,\n due_date = None,\n priority = None,\n tags = None,\n repeat = None,\n estimated = None,\n):\n\n smart = [re.sub(r'(^| )([@^!#*=])', r'\\1\\\\\\2', name)]\n\n if due_date:\n smart.append('^' + due_date)\n\n if priority:\n smart.append('!' + str(priority))\n\n if tags:\n smart.extend(['#' + t for t in tags])\n\n if repeat:\n smart.append('*' + repeat)\n\n if estimated:\n smart.append('=' + estimated)\n\n return ' '.join(smart)","def rehydrate_thematic_break(cls, next_token):\n return next_token.extracted_whitespace + next_token.rest_of_line + \"\\n\"","def token(self) -> str:","def __encode_token(self, text: list) -> dict:\n encoded_input = self.tokenizer(\n [str(string) for string in text],\n truncation=True,\n padding=True,\n return_tensors=\"pt\",\n )\n\n return encoded_input","def insert(self, w: str) -> None:\n if not w:\n self.end = True\n else:\n self.d[w[0]].insert((len(w) > 1 and w[1:]) or '')","def normalise_query(query: str) -> str:\n return EXTRA_WHITE_SPACE.sub(' ', query.strip())","def make_space_quotes(data, words_with_quotes):\n sentences = data.split('\\n')\n new_sentences = []\n for sen in sentences:\n words = sen.split()\n new_words = []\n for word in words:\n splitted_by_quote = word.split(\"״\")\n bounds = [0, len(word) - 1]\n if word not in words_with_quotes and len(splitted_by_quote) > 0 and word.find(\"״\") in bounds:\n new_word = \" ״ \".join(splitted_by_quote).strip()\n new_words.append(new_word)\n else:\n new_words.append(word)\n new_sentences.append(\" \".join(new_words))\n return \"\\n\".join(new_sentences)","def __add__(self, other):\n if other is Ellipsis:\n return _PendingSkip(self)\n\n return And(\n [self, whitespaces.CURRENT.normalize(other)], whitespaces.CURRENT\n ).streamline()","def add(self, word):\r\n if not word or word.strip() == '':\r\n return\r\n self.words.append(word)","def tokens_to_string(self, tokens):\n\n # Create a list of the individual words.\n words = [self.index_to_word[token]\n for token in tokens\n if token != 0]\n\n # Concatenate the words to a single string\n # with space between all the words.\n text = \" \".join(words)\n\n return text","def _to_space_separated_string(l):\n s = '';\n for x in l:\n if len(s)>0: s += ' '\n s += repr(x)\n return s","def get_parse_filter_text(conversation: Conversation):\n parse_op = gen_parse_op_text(conversation)\n if len(parse_op) > 0:\n intro_text = f\"For the data with <b>{parse_op}</b>,\"\n else:\n intro_text = \"For <b>all</b> the instances in the data,\"\n return intro_text","def 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 format(token, word, start, end, groundtruth, prediction, delimiter='\\t'):\n out = ''\n for t, w, s, e, g, p in zip(token, word, start, end, groundtruth, prediction):\n out += delimiter.join((t, w, s, e, g, p)) + '\\n'\n return out","def add_sentence(self, sentence):\n for word in sentence.split(' '):\n self.add_word(word)","def add_sentence(self, sentence):\n for word in sentence.split(' '):\n self.add_word(word)","def encode1(arr):\n rv = ''\n for item in arr:\n if rv != '':\n rv += '+,'\n for char in item:\n if char == '+':\n rv += '++'\n else:\n rv += char\n return rv","def add_special_tokens_sentences_pair(self, token_ids_0, token_ids_1):\n sep = [self._convert_token_to_id(self.sep_token)]\n cls = [self._convert_token_to_id(self.cls_token)]\n return token_ids_0 + sep + token_ids_1 + sep + cls","def to_string(self):\n filter_string = '('\n variable_length = len(self.values) - 1\n for index in range(0, variable_length + 1):\n filter_string += '&' + self.values[index]\n # append or for all but the last\n if index < variable_length:\n filter_string += self.combination_operator\n filter_string += ')'\n\n return filter_string","def append(self, s):\n self.result += ' ' * self.indent + s + '\\n'","def space_detokenizer(batch: List[List[str]]) -> List[str]:\n return [\" \".join(tokens) for tokens in batch]","def _preprocess(self, sent: str) -> str:\n sent = sent.replace(\" \", \"▁\")\n return \" \".join([c for c in sent])"],"string":"[\n \"def add_spaces(text):\\n return \\\" \\\".join(text)\",\n \"def _remove_extra_whitespaces(self, text: str) -> str:\\n return re.sub(\\\" +\\\", \\\" \\\", text)\",\n \"def wrapspace(text, token):\\n\\n # Wildcards have no whitespace. Need special case since * is also multiply which does have whitespace.\\n if token in [\\\"*\\\"] and (not text or text.endswith((\\\" \\\", \\\"(\\\"))):\\n return token\\n\\n # Operator whitespace\\n if Token.isoperator(token) or Token.islogicseparator(token) or token.lower() in [\\\"in\\\"]:\\n return f\\\" {token} \\\" if not text.endswith(\\\" \\\") else f\\\"{token} \\\"\\n\\n # Comma whitespace\\n if Token.isseparator(token):\\n return f\\\"{token} \\\"\\n\\n # No whitespace if any of the following is True\\n if not text or text.endswith((\\\" \\\", \\\"(\\\", \\\"[\\\")) or token in [\\\"(\\\", \\\"[\\\", \\\")\\\", \\\"]\\\"] or token.startswith(\\\".\\\"):\\n return token\\n\\n # Default is to add leading whitespace\\n return f\\\" {token}\\\"\",\n \"def add_special_tokens_single_sentence(self, token_ids):\\r\\n return [self.token_to_id(self.cls_token)] + token_ids + [self.token_to_id(self.sep_token)]\",\n \"def _build_add(self) -> str:\\n return dedent(\\n \\\"\\\"\\\"\\n @SP\\n M=M-1\\n A=M\\n D=M\\n @SP\\n M=M-1\\n A=M\\n M=M+D\\n @SP\\n M=M+1\\n \\\"\\\"\\\"\\n )\",\n \"def add_special_tokens_single_sentence(self, token_ids):\\n return [self.cls_token_id] + token_ids + [self.sep_token_id]\",\n \"def join(self, tokens):\\n if self.chars:\\n joiner = ''\\n else:\\n joiner = ' '\\n return joiner.join(tokens)\",\n \"def sep(s):\\n return ' '+s if s else s\",\n \"def concatenate_processed_text(self):\\n\\n\\n\\t\\tconcatenated_text = \\\"\\\"\\n\\t\\tfor line in self.processed_text:\\n\\t\\t\\tconcatenated_text += \\\" \\\".join(line) + \\\" \\\"\\n\\n\\n\\t\\t# Remove the trailing space character from the concatenated string\\n\\t\\t# of words.\\n\\t\\tconcatenated_text = concatenated_text[:-1]\\n\\n\\t\\tself.concatenated_text = concatenated_text\",\n \"def get_insert_token(self, word):\\n # Insert word choose\\n return ''.join([word] * 2)\",\n \"def _build_and(self) -> str:\\n return dedent(\\n \\\"\\\"\\\"\\n @SP\\n M=M-1\\n A=M\\n D=M\\n @SP\\n M=M-1\\n A=M\\n M=M&D\\n @SP\\n M=M+1\\n \\\"\\\"\\\"\\n )\",\n \"def camma_plus(s):\\n return s+\\\",\\\"\",\n \"def __str__(self):\\n if self._tokens == '*' or self._tokens == '':\\n return self._tokens\\n self.compact()\\n return \\\"\\\".join(str(s[0])+s[1] for s in self._tokens)\",\n \"def add_special_tokens_single_sentence(self, token_ids):\\n sep = [self._convert_token_to_id(self.sep_token)]\\n cls = [self._convert_token_to_id(self.cls_token)]\\n return token_ids + sep + cls\",\n \"def quote_plus(s, safe='', encoding=None, errors=None):\\n if ' ' in s:\\n s = quote(s, safe + ' ', encoding, errors)\\n return s.replace(' ', '+')\\n return quote(s, safe, encoding, errors)\",\n \"def concat_text(self, elem):\\n\\n s = u\\\" \\\".join([ frag.strip() for frag in elem.itertext() if re.search(\\\"\\\\S\\\", frag) ]) \\n return re.sub(\\\" (\\\\W )\\\", \\\"\\\\\\\\1\\\", s)\",\n \"def gen_parse_op_text(conversation):\\n ret_text = \\\"\\\"\\n conv_parse_ops = conversation.parse_operation\\n for i in range(1, len(conv_parse_ops)):\\n ret_text += conv_parse_ops[i] + \\\" \\\"\\n ret_text = ret_text[:-1]\\n return ret_text\",\n \"def __radd__(self, other):\\n return Token(\\n other + self.text, self.position - len(other), self.category)\",\n \"def add_separator(self, structure, word, debug=False):\\n word_segmented = list(word)\\n char = 0\\n forward = 0\\n while char < len(structure) - 1:\\n if structure[char] == '-':\\n word_segmented.insert(char + forward, '-')\\n elif structure[char] == 'T':\\n forward += 1 # moving one forward because T is mapped to two characters\\n char += 1\\n\\n if debug:\\n print(structure, word, word_segmented, ''.join(word_segmented))\\n\\n return ''.join(word_segmented)\",\n \"def add_tokens(self, tokens):\\n self.result.extend([d for d in tokens])\",\n \"def str (self, max_len_first, max_len_following=0) :\\r\\n\\r\\n\\t\\t## This version indents continuation lines by 1 space\\r\\n\\t\\tif not max_len_following == 0 :\\r\\n\\t\\t\\tmax_len_following -= 1\\r\\n\\t\\t\\r\\n\\t\\tresult = tokenizer.join_tokens(self.tokens, max_len_first, max_len_following)\\r\\n\\t\\tresult[1:] = [ (\\\" \\\" + r) for r in result[1:] ]\\r\\n\\r\\n\\t\\treturn [result]\",\n \"def to_whitespace(self, empty=False, strip_nl=False, strip_comments=False):\\n if strip_nl and self.type == tokenize.NL:\\n self.string = \\\"\\\"\\n return\\n if strip_comments and self.type == tokenize.COMMENT:\\n self.string = \\\"\\\"\\n return\\n if self.type in ignored_types_set:\\n return\\n if empty:\\n self.string = \\\"\\\"\\n else:\\n self.string = \\\" \\\" * len(self.token_tuple[1])\",\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 tokenized(self, text):\\n return self.tokenizer.encode_plus(text,\\n max_length=512,\\n pad_to_max_length=True,\\n truncation=True)[\\\"input_ids\\\"]\",\n \"def insert_spaces(word):\\n new_word = \\\"\\\"\\n for c in word:\\n new_word += c + \\\" \\\" \\n return new_word\",\n \"def reduce_spaces(tweet):\\r\\n text = tweet.strip()\\r\\n text = \\\" \\\".join(text.split())\\r\\n return re.sub(' +', ' ', text)\",\n \"def concat_text(text):\\n textout = \\\" \\\".join(text)\\n return textout\",\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__(self, other):\\n space = '' if other.type == 'punctuation' else ' '\\n new = Word('0.0', '0.0', self.word + space + other.word, self.type)\\n new.start = self.start\\n new.end = other.end\\n return new\",\n \"def convert_spaces(msg_list):\\n new_list = []\\n for str in msg_list:\\n new_list.append(str.replace(' ', '+'))\\n return (new_list)\",\n \"def get_orion_space_string(self) -> str:\",\n \"def preproc_user_input(txt, model):\\r\\n txt = pre_process(txt)\\r\\n txt_tokenized = [word for word in txt.split(\\\" \\\") if word in model.wv.vocab]\\r\\n return \\\" \\\".join(txt_tokenized)\",\n \"def token_chain(text, filters):\\n if filters is None:\\n return text\\n\\n sb = \\\"\\\"\\n for token in RegexFilters.WHITESPACE.split(text):\\n if not classifier_options.is_special_class_word(token):\\n token = Filters.string_chain(token, filters)\\n\\n sb += token + \\\" \\\"\\n\\n return sb\",\n \"def andify(things: list):\\n if len(things) < 1:\\n return \\\"\\\"\\n return (f'{\\\", \\\".join(things[:-1])}' +\\n f'{\\\", and \\\" if len(things) > 2 else (\\\" and \\\" if len(things) > 1 else \\\"\\\")}' +\\n f'{things[-1]}')\",\n \"def remove_extra_space(text):\\n return re.sub(' +', ' ', text)\",\n \"def word_join(self, words):\\n return \\\" \\\".join(words)\",\n \"def _concat(self, *args, **kwargs):\\n values = list(args)\\n output = []\\n for value in values:\\n if not isinstance(value, (str, basestring)):\\n value = unicode(value)\\n else:\\n value = unicode(value)\\n value = value.strip()\\n output.append(value)\\n output = kwargs[\\\"delimiter\\\"].join(output)\\n output = unicode(output)\\n return output\",\n \"def simplify(text, whitespace=string.whitespace, delete=\\\"\\\"):\\n result = []\\n word = \\\"\\\"\\n for char in text:\\n if char in delete:\\n continue\\n elif char in whitespace:\\n if word:\\n result.append(word)\\n word = \\\"\\\"\\n else:\\n word += char\\n if word:\\n result.append(word)\\n return \\\" \\\".join(result)\",\n \"def _add_to_expression(self, item):\\n addition = ' {%s} ' % item.text()\\n expression = self.ui.expression\\n pos = expression.cursorPosition()\\n text = str(expression.displayText())\\n expression.setText(text[:pos] + addition + text[pos:])\",\n \"def comma_for_space(x):\\n x = strip_stoich_wrapper(x)\\n x = x.replace(\\\" \\\", \\\",\\\")\\n return x\",\n \"def whisper(*text: str, sep=' '):\\n return f'<amazon:effect name=”whispered”>{sep.join(text)}</amazon:effect>'\",\n \"def reformat_search_for_spaces(self):\\r\\n self.yt_search_key = self.yt_search_key.rstrip().replace(' ', '+')\",\n \"def _despace(statement):\\n return re.sub(r' +', ' ', statement)\",\n \"def replace_spaces_with_pluses(self, sample):\\r\\n changed = list(sample)\\r\\n for i, c in enumerate(changed):\\r\\n if(c == ' ' or c ==' ' or c ==' ' or c=='\\\\n' or c=='\\\\n\\\\n'):\\r\\n changed[i] = '+'\\r\\n return ''.join(changed)\",\n \"def _preprocess(self, tagged: List[Tuple]) -> str:\\n ori = \\\" \\\".join([tag[0] for tag in tagged if tag[1] != \\\"SPACE\\\"])\\n sent = \\\" \\\".join([tag[1] for tag in tagged if tag[1] != \\\"SPACE\\\"])\\n sent = sent.replace(\\\"-LRB-\\\", \\\"(\\\")\\n sent = sent.replace(\\\"-RRB-\\\", \\\")\\\")\\n return sent, ori\",\n \"def words_string(self):\\n return ' '.join(self.words).replace(' - ', '')\",\n \"def concat_tokens(tokens, token_filter=None):\\n # The following assertion is to aid in debugging a common but\\n # difficult-to-pinpoint programming mistake.\\n assert not isinstance(tokens, (str, unicode)), (\\n 'concat_tokens() was passed a string rather than a sequence of tokens.\\\\n\\\\n tokens[:100]:\\\\n %s'\\n % repr(tokens[:100])\\n )\\n try:\\n if token_filter:\\n return ''.join([token.xml for token in tokens if isinstance(token, token_filter)])\\n else:\\n return ''.join([token.xml for token in tokens])\\n except AttributeError, value:\\n raise RexlibError('An AttributeError was raised in concat_tokens(): %s' % value)\",\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 _concatenate_instance(\\n self,\\n emotion: str,\\n target_utterance: str,\\n evidence_utterance: str,\\n conversation_history: str,\\n ) -> str:\\n concatenated_text = (\\n \\\" \\\"\\n + emotion\\n + \\\" <SEP> \\\"\\n + target_utterance\\n + \\\" <SEP> \\\"\\n + evidence_utterance\\n + \\\" <SEP> \\\"\\n + conversation_history\\n )\\n\\n return concatenated_text\",\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 pre_process(text: str) -> str:\\n text = text.replace('--', '-')\\n space_right = '!?:;,.-()*+-/<=>@^_'\\n space_both = '-()*+-/<=>@^_'\\n\\n for punct in space_right:\\n text = text.replace(punct, punct + ' ')\\n for punct in space_both:\\n text = text.replace(punct, ' ' + punct + ' ')\\n\\n # remove extra space\\n text = re.sub(r' +', ' ', text)\\n return text\",\n \"def __add(thiselement, char):\\n if thiselement == None:\\n return char\\n return thiselement + char\",\n \"def remove_extra_space(text):\\n text = \\\" \\\".join(text.split())\\n return text\",\n \"def __add__(self, other):\\n if type(other) == str:\\n return str(self) + other\",\n \"def __add__(self, chars):\\n newdata = list(self.data) + list(str(chars))\\n return MutableString(''.join(newdata))\",\n \"def _commandline_join(self, tokens):\\r\\n commands = filter(None, map(str, tokens))\\r\\n return self._command_delimiter.join(commands).strip()\",\n \"def _commandline_join(self, tokens):\\r\\n commands = filter(None, map(str, tokens))\\r\\n return self._command_delimiter.join(commands).strip()\",\n \"def _commandline_join(self, tokens):\\r\\n commands = filter(None, map(str, tokens))\\r\\n return self._command_delimiter.join(commands).strip()\",\n \"def convert_to_string(tokens):\\n\\n return ' '.join(tokens)\",\n \"def _add_text(self, elem):\\n words = WORD_SEPARATORS.split(elem.string.lower())\\n for word in words:\\n word = word.strip()\\n if word in self._ignored_words:\\n continue\\n self._curr_words.append((self.crawler.word_id(word), self._font_size))\",\n \"def concatenate_items(items, conjunction='and'):\\n text = ''\\n if not items:\\n text = ''\\n elif len(items) == 1:\\n text = items[0]\\n elif len(items) == 2:\\n text = '{} {} {}'.format(items[0], conjunction, items[1])\\n else:\\n text = ', '.join(items[:-1])\\n text += ', {} {}'.format(conjunction, items[-1])\\n return text\",\n \"def merge_wv_t1_eng(where_str_tokens, NLq):\\r\\n nlq = NLq.lower()\\r\\n where_str_tokens = [tok.lower() for tok in where_str_tokens]\\r\\n alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789$'\\r\\n special = {'-LRB-': '(',\\r\\n '-RRB-': ')',\\r\\n '-LSB-': '[',\\r\\n '-RSB-': ']',\\r\\n '``': '\\\"',\\r\\n '\\\\'\\\\'': '\\\"',\\r\\n }\\r\\n # '--': '\\\\u2013'} # this generate error for test 5661 case.\\r\\n ret = ''\\r\\n double_quote_appear = 0\\r\\n for raw_w_token in where_str_tokens:\\r\\n # if '' (empty string) of None, continue\\r\\n if not raw_w_token:\\r\\n continue\\r\\n\\r\\n # Change the special characters\\r\\n w_token = special.get(raw_w_token, raw_w_token) # maybe necessary for some case?\\r\\n\\r\\n # check the double quote\\r\\n if w_token == '\\\"':\\r\\n double_quote_appear = 1 - double_quote_appear\\r\\n\\r\\n # Check whether ret is empty. ret is selected where condition.\\r\\n if len(ret) == 0:\\r\\n pass\\r\\n # Check blank character.\\r\\n elif len(ret) > 0 and ret + ' ' + w_token in nlq:\\r\\n # Pad ' ' if ret + ' ' is part of nlq.\\r\\n ret = ret + ' '\\r\\n\\r\\n elif len(ret) > 0 and ret + w_token in nlq:\\r\\n pass # already in good form. Later, ret + w_token will performed.\\r\\n\\r\\n # Below for unnatural question I guess. Is it likely to appear?\\r\\n elif w_token == '\\\"':\\r\\n if double_quote_appear:\\r\\n ret = ret + ' ' # pad blank line between next token when \\\" because in this case, it is of closing apperas\\r\\n # for the case of opening, no blank line.\\r\\n\\r\\n elif w_token[0] not in alphabet:\\r\\n pass # non alphabet one does not pad blank line.\\r\\n\\r\\n # when previous character is the special case.\\r\\n elif (ret[-1] not in ['(', '/', '\\\\u2013', '#', '$', '&']) and (ret[-1] != '\\\"' or not double_quote_appear):\\r\\n ret = ret + ' '\\r\\n ret = ret + w_token\\r\\n\\r\\n return ret.strip()\",\n \"def encode(inp, typee, dictt):\\r\\n inp_str = inp.decode(\\\"utf-8\\\")\\r\\n if \\\"x\\\" in typee:\\r\\n tokens = inp_str.split() + [\\\"</s>\\\"]\\r\\n else:\\r\\n tokens = [\\\"<s>\\\"] + inp_str.split() + [\\\"</s>\\\"]\\r\\n\\r\\n x = [dictt.get(t, dictt[\\\"<unk>\\\"]) for t in tokens]\\r\\n return x\",\n \"def joined_parameter(*values: str) -> str:\\n return \\\"+\\\".join(values)\",\n \"def edit_tokens (input_words):\\n length = len(input_words)\\n for i, w in enumerate(input_words):\\n if (w == \\\"{\\\"):\\n if (i+2 < length):\\n if (input_words[i+2] == \\\"}\\\"):\\n input_words[i:i+3] = [''.join(input_words[i:i+3])]\\n return input_words\",\n \"def _add_val(self, val):\\n if not val or val == \\\"{}\\\":\\n return ''\\n val = self._strip_braces(val)\\n val = self._strip_quotes(val)\\n val = self._strip_braces(val)\\n val = self._string_subst(val)\\n return val\",\n \"def removeExtraSpaces(self, words):\\n\\t\\treturn re.sub(r'\\\\s+', ' ', words.strip()).strip()\",\n \"def remocion_de_espacios(self, texto):\\n \\n texto = re.sub(' +', ' ', texto)\\n return texto.strip()\",\n \"def tokenize(eq):\\n\\n def push(token):\\n if token != \\\"\\\":\\n if token[0].isdigit():\\n tokens.append(int(token))\\n else:\\n tokens.append(token)\\n\\n tokens = []\\n token = \\\"\\\"\\n\\n for t in eq:\\n if t == \\\" \\\":\\n push(token)\\n token = \\\"\\\"\\n if t == \\\"+\\\" or t == \\\"*\\\" or t == \\\"(\\\" or t == \\\")\\\":\\n push(token)\\n push(t)\\n token = \\\"\\\"\\n elif t.isdigit():\\n token += t\\n\\n push(token)\\n return tokens\",\n \"def add_padding(self, text):\\n\\n for word in text.split(' '):\\n # 5 character blocks added straight\\n if len(word) == 5:\\n self.output += word + ' '\\n # calling the helper method to fill the blocks\\n elif len(word) < 5:\\n self._helper(word)\\n # split the block up into 5 letter chunks\\n elif len(word) > 5:\\n block = ''\\n for letter in word:\\n block += letter\\n if len(block) == 5:\\n # append the chunk to output\\n self.output += block + ' '\\n block = ''\\n self._helper(block)\\n\\n return self.output.upper()\",\n \"def add_special_tokens_sentences_pair(self, token_ids_0, token_ids_1):\\r\\n sep = [self.token_to_id(self.sep_token)]\\r\\n cls = [self.token_to_id(self.cls_token)]\\r\\n return cls + token_ids_0 + sep + sep + token_ids_1 + sep\",\n \"def add_special_tokens_sentences_pair(self, token_ids_0, token_ids_1):\\n sep = [self.sep_token_id]\\n cls = [self.cls_token_id]\\n return cls + token_ids_0 + sep + token_ids_1 + sep\",\n \"def add(text):\\n orig = dispb[\\\"text\\\"]\\n new = orig + text\\n ops = [\\\"+\\\",\\\"-\\\",\\\"*\\\",\\\"/\\\"]\\n # conditions\\n # length 21\\n if len(new) > 21:\\n dispb[\\\"text\\\"] = orig\\n return 0\\n \\n # one calc at a time\\n if len(orig) > 0:\\n if (orig[-1] in ops) & (text in ops):\\n dispb[\\\"text\\\"] = orig\\n return 0\\n\\n dispb[\\\"text\\\"] = new\\n return 0\",\n \"def remove_space(user_inputs):\\r\\n return user_inputs.replace(\\\" \\\", \\\"\\\")\",\n \"def print_new_word(self,word):\\n new_word = ''\\n for i in word:\\n new_word+= i\\n return new_word\",\n \"def punctuation(self, value):\\n value = re.sub('_', ' ', value)\\n value = re.sub(',', ' ', value)\\n value = re.sub('\\\\'', ' ', value)\\n value = re.sub(r'[^\\\\w\\\\s]','', value)\\n value = re.sub(r'\\\\s+',' ',value)\\n return value\",\n \"def join_with_and(values, last_word: str = 'and') -> str:\\n valuesList = list(values)\\n length = len(valuesList)\\n\\n # value1, value2, value3 and value4\\n if length > 2:\\n return '{} {} {}'.format(', '.join(valuesList[:-1]), last_word, valuesList[-1])\\n # value1 and value2\\n elif length == 2:\\n return '{} {} {}'.format(valuesList[0], last_word, valuesList[1])\\n # value 1\\n elif length == 1:\\n return valuesList[0]\\n # Empty\\n return ''\",\n \"def simple_tokeniser(sent):\\n sent = re_tok_apos.sub(r\\\"\\\\1 's\\\", sent)\\n sent = re_tok_mw_punc.sub(r\\\"\\\\1 \\\\2\\\", sent)\\n sent = re_tok_punc.sub(r\\\" \\\\1 \\\", sent).replace('-', ' - ')\\n sent = re_tok_punc.sub(r\\\" \\\\1 \\\", sent)\\n sent = re_tok_mult_space.sub(' ', sent)\\n return sent.lower().split()\",\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 smart_add(\\n name = None,\\n due_date = None,\\n priority = None,\\n tags = None,\\n repeat = None,\\n estimated = None,\\n):\\n\\n smart = [re.sub(r'(^| )([@^!#*=])', r'\\\\1\\\\\\\\\\\\2', name)]\\n\\n if due_date:\\n smart.append('^' + due_date)\\n\\n if priority:\\n smart.append('!' + str(priority))\\n\\n if tags:\\n smart.extend(['#' + t for t in tags])\\n\\n if repeat:\\n smart.append('*' + repeat)\\n\\n if estimated:\\n smart.append('=' + estimated)\\n\\n return ' '.join(smart)\",\n \"def rehydrate_thematic_break(cls, next_token):\\n return next_token.extracted_whitespace + next_token.rest_of_line + \\\"\\\\n\\\"\",\n \"def token(self) -> str:\",\n \"def __encode_token(self, text: list) -> dict:\\n encoded_input = self.tokenizer(\\n [str(string) for string in text],\\n truncation=True,\\n padding=True,\\n return_tensors=\\\"pt\\\",\\n )\\n\\n return encoded_input\",\n \"def insert(self, w: str) -> None:\\n if not w:\\n self.end = True\\n else:\\n self.d[w[0]].insert((len(w) > 1 and w[1:]) or '')\",\n \"def normalise_query(query: str) -> str:\\n return EXTRA_WHITE_SPACE.sub(' ', query.strip())\",\n \"def make_space_quotes(data, words_with_quotes):\\n sentences = data.split('\\\\n')\\n new_sentences = []\\n for sen in sentences:\\n words = sen.split()\\n new_words = []\\n for word in words:\\n splitted_by_quote = word.split(\\\"״\\\")\\n bounds = [0, len(word) - 1]\\n if word not in words_with_quotes and len(splitted_by_quote) > 0 and word.find(\\\"״\\\") in bounds:\\n new_word = \\\" ״ \\\".join(splitted_by_quote).strip()\\n new_words.append(new_word)\\n else:\\n new_words.append(word)\\n new_sentences.append(\\\" \\\".join(new_words))\\n return \\\"\\\\n\\\".join(new_sentences)\",\n \"def __add__(self, other):\\n if other is Ellipsis:\\n return _PendingSkip(self)\\n\\n return And(\\n [self, whitespaces.CURRENT.normalize(other)], whitespaces.CURRENT\\n ).streamline()\",\n \"def add(self, word):\\r\\n if not word or word.strip() == '':\\r\\n return\\r\\n self.words.append(word)\",\n \"def tokens_to_string(self, tokens):\\n\\n # Create a list of the individual words.\\n words = [self.index_to_word[token]\\n for token in tokens\\n if token != 0]\\n\\n # Concatenate the words to a single string\\n # with space between all the words.\\n text = \\\" \\\".join(words)\\n\\n return text\",\n \"def _to_space_separated_string(l):\\n s = '';\\n for x in l:\\n if len(s)>0: s += ' '\\n s += repr(x)\\n return s\",\n \"def get_parse_filter_text(conversation: Conversation):\\n parse_op = gen_parse_op_text(conversation)\\n if len(parse_op) > 0:\\n intro_text = f\\\"For the data with <b>{parse_op}</b>,\\\"\\n else:\\n intro_text = \\\"For <b>all</b> the instances in the data,\\\"\\n return intro_text\",\n \"def 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 format(token, word, start, end, groundtruth, prediction, delimiter='\\\\t'):\\n out = ''\\n for t, w, s, e, g, p in zip(token, word, start, end, groundtruth, prediction):\\n out += delimiter.join((t, w, s, e, g, p)) + '\\\\n'\\n return out\",\n \"def add_sentence(self, sentence):\\n for word in sentence.split(' '):\\n self.add_word(word)\",\n \"def add_sentence(self, sentence):\\n for word in sentence.split(' '):\\n self.add_word(word)\",\n \"def encode1(arr):\\n rv = ''\\n for item in arr:\\n if rv != '':\\n rv += '+,'\\n for char in item:\\n if char == '+':\\n rv += '++'\\n else:\\n rv += char\\n return rv\",\n \"def add_special_tokens_sentences_pair(self, token_ids_0, token_ids_1):\\n sep = [self._convert_token_to_id(self.sep_token)]\\n cls = [self._convert_token_to_id(self.cls_token)]\\n return token_ids_0 + sep + token_ids_1 + sep + cls\",\n \"def to_string(self):\\n filter_string = '('\\n variable_length = len(self.values) - 1\\n for index in range(0, variable_length + 1):\\n filter_string += '&' + self.values[index]\\n # append or for all but the last\\n if index < variable_length:\\n filter_string += self.combination_operator\\n filter_string += ')'\\n\\n return filter_string\",\n \"def append(self, s):\\n self.result += ' ' * self.indent + s + '\\\\n'\",\n \"def space_detokenizer(batch: List[List[str]]) -> List[str]:\\n return [\\\" \\\".join(tokens) for tokens in batch]\",\n \"def _preprocess(self, sent: str) -> str:\\n sent = sent.replace(\\\" \\\", \\\"▁\\\")\\n return \\\" \\\".join([c for c in sent])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6040225","0.5965436","0.565226","0.55917454","0.5590612","0.5502032","0.54759145","0.54269254","0.5407506","0.537984","0.5370962","0.5360763","0.53585404","0.53528565","0.5322174","0.53027683","0.52994215","0.5293425","0.5283788","0.52749795","0.5263112","0.52551985","0.5238688","0.5233864","0.52309614","0.5230744","0.52293944","0.5219619","0.52111655","0.52066296","0.51650685","0.515309","0.51054364","0.50928444","0.5083517","0.50816315","0.5076479","0.5026455","0.5014406","0.5012611","0.5006202","0.4984673","0.49372432","0.49313346","0.49298924","0.49283347","0.49209234","0.49130312","0.49092367","0.49085325","0.49074537","0.48956192","0.48715457","0.48687527","0.4860556","0.48367316","0.48367316","0.48367316","0.48319033","0.48226824","0.48224196","0.4821877","0.48176974","0.4814276","0.48084605","0.48075348","0.48059562","0.48041502","0.48021087","0.4799955","0.47996315","0.47728845","0.47627756","0.475741","0.4753416","0.47325295","0.4731727","0.47221893","0.47194067","0.47181228","0.4709071","0.47088426","0.47029644","0.47025886","0.47012612","0.46947116","0.46928537","0.46923405","0.46815154","0.46753368","0.46737167","0.4671301","0.46654156","0.46629176","0.46629176","0.46485975","0.46457258","0.46421206","0.4639754","0.46390492","0.46388996"],"string":"[\n \"0.6040225\",\n \"0.5965436\",\n \"0.565226\",\n \"0.55917454\",\n \"0.5590612\",\n \"0.5502032\",\n \"0.54759145\",\n \"0.54269254\",\n \"0.5407506\",\n \"0.537984\",\n \"0.5370962\",\n \"0.5360763\",\n \"0.53585404\",\n \"0.53528565\",\n \"0.5322174\",\n \"0.53027683\",\n \"0.52994215\",\n \"0.5293425\",\n \"0.5283788\",\n \"0.52749795\",\n \"0.5263112\",\n \"0.52551985\",\n \"0.5238688\",\n \"0.5233864\",\n \"0.52309614\",\n \"0.5230744\",\n \"0.52293944\",\n \"0.5219619\",\n \"0.52111655\",\n \"0.52066296\",\n \"0.51650685\",\n \"0.515309\",\n \"0.51054364\",\n \"0.50928444\",\n \"0.5083517\",\n \"0.50816315\",\n \"0.5076479\",\n \"0.5026455\",\n \"0.5014406\",\n \"0.5012611\",\n \"0.5006202\",\n \"0.4984673\",\n \"0.49372432\",\n \"0.49313346\",\n \"0.49298924\",\n \"0.49283347\",\n \"0.49209234\",\n \"0.49130312\",\n \"0.49092367\",\n \"0.49085325\",\n \"0.49074537\",\n \"0.48956192\",\n \"0.48715457\",\n \"0.48687527\",\n \"0.4860556\",\n \"0.48367316\",\n \"0.48367316\",\n \"0.48367316\",\n \"0.48319033\",\n \"0.48226824\",\n \"0.48224196\",\n \"0.4821877\",\n \"0.48176974\",\n \"0.4814276\",\n \"0.48084605\",\n \"0.48075348\",\n \"0.48059562\",\n \"0.48041502\",\n \"0.48021087\",\n \"0.4799955\",\n \"0.47996315\",\n \"0.47728845\",\n \"0.47627756\",\n \"0.475741\",\n \"0.4753416\",\n \"0.47325295\",\n \"0.4731727\",\n \"0.47221893\",\n \"0.47194067\",\n \"0.47181228\",\n \"0.4709071\",\n \"0.47088426\",\n \"0.47029644\",\n \"0.47025886\",\n \"0.47012612\",\n \"0.46947116\",\n \"0.46928537\",\n \"0.46923405\",\n \"0.46815154\",\n \"0.46753368\",\n \"0.46737167\",\n \"0.4671301\",\n \"0.46654156\",\n \"0.46629176\",\n \"0.46629176\",\n \"0.46485975\",\n \"0.46457258\",\n \"0.46421206\",\n \"0.4639754\",\n \"0.46390492\",\n \"0.46388996\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12894,"cells":{"query":{"kind":"string","value":"Almost copied of SQLNet. The main purpose is pad blank line while combining tokens."},"document":{"kind":"string","value":"def merge_wv_t1_eng(where_str_tokens, NLq):\r\n nlq = NLq.lower()\r\n where_str_tokens = [tok.lower() for tok in where_str_tokens]\r\n alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789$'\r\n special = {'-LRB-': '(',\r\n '-RRB-': ')',\r\n '-LSB-': '[',\r\n '-RSB-': ']',\r\n '``': '\"',\r\n '\\'\\'': '\"',\r\n }\r\n # '--': '\\u2013'} # this generate error for test 5661 case.\r\n ret = ''\r\n double_quote_appear = 0\r\n for raw_w_token in where_str_tokens:\r\n # if '' (empty string) of None, continue\r\n if not raw_w_token:\r\n continue\r\n\r\n # Change the special characters\r\n w_token = special.get(raw_w_token, raw_w_token) # maybe necessary for some case?\r\n\r\n # check the double quote\r\n if w_token == '\"':\r\n double_quote_appear = 1 - double_quote_appear\r\n\r\n # Check whether ret is empty. ret is selected where condition.\r\n if len(ret) == 0:\r\n pass\r\n # Check blank character.\r\n elif len(ret) > 0 and ret + ' ' + w_token in nlq:\r\n # Pad ' ' if ret + ' ' is part of nlq.\r\n ret = ret + ' '\r\n\r\n elif len(ret) > 0 and ret + w_token in nlq:\r\n pass # already in good form. Later, ret + w_token will performed.\r\n\r\n # Below for unnatural question I guess. Is it likely to appear?\r\n elif w_token == '\"':\r\n if double_quote_appear:\r\n ret = ret + ' ' # pad blank line between next token when \" because in this case, it is of closing apperas\r\n # for the case of opening, no blank line.\r\n\r\n elif w_token[0] not in alphabet:\r\n pass # non alphabet one does not pad blank line.\r\n\r\n # when previous character is the special case.\r\n elif (ret[-1] not in ['(', '/', '\\u2013', '#', '$', '&']) and (ret[-1] != '\"' or not double_quote_appear):\r\n ret = ret + ' '\r\n ret = ret + w_token\r\n\r\n return ret.strip()"},"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 _output_padding_line(self):\n for i in range(self.num_new_columns):\n self._write_column(self.new_columns[i], '|')\n self.buf += ' '\n\n self._pad_horizontally(self.num_new_columns * 2)","def rehydrate_blank_line(cls, next_token):\n return next_token.extracted_whitespace + \"\\n\"","def rehydrate_thematic_break(cls, next_token):\n return next_token.extracted_whitespace + next_token.rest_of_line + \"\\n\"","def mywrap(text):\n text = text.replace(\"\\n\\n\", \"\\n\").replace(\"\\n\", \"\\n \").rstrip()\n return text","def _padding_line(self):\n if self.state != GraphState.COMMIT:\n self._next_line()\n return\n\n # Output the row containing this commit\n # Iterate up to and including self.num_columns, since the current commit\n # may not be in any of the existing columns. (This happens when the\n # current commit doesn't have any children that we have already\n # processed.)\n for i in range(self.num_columns):\n col = self.columns[i]\n self._write_column(col, '|')\n if col.commit == self.commit and self.num_parents > 2:\n self.buf += ' ' * (self.num_parents - 2) * 2\n else:\n self.buf += ' '\n\n self._pad_horizontally(self.num_columns)\n\n # Update self.prev_state since we have output a padding line\n self.prev_state = GraphState.PADDING","def justify_token(tok, col_width):\n get_len = tools.display_len if PY3 else len\n tok_len = get_len(tok)\n diff_len = tok_len - len(tok) if PY3 else 0\n\n cols = (int(math.ceil(float(tok_len) / col_width))\n if col_width < tok_len + 4 else 1)\n\n if cols > 1:\n return tok.ljust((col_width * cols) + (4 * cols) - diff_len)\n else:\n return tok.ljust(col_width + 4 - diff_len)","def join(self, tokens):\n if self.chars:\n joiner = ''\n else:\n joiner = ' '\n return joiner.join(tokens)","def _newline(self):\n if prettyprint:\n return '\\n' + self._indent_spaces()\n else:\n return ''","def full_tokens(tokens):\n target_length = roundup2(len(tokens))\n padding_length = target_length - len(tokens)\n tokens = [PADDING_TOKEN] * padding_length + tokens\n return tokens","def pad_string(text, pad):\n\tpad_str = ''\n\tresult = ''\n\tif (type(pad) is int):\n\t\tpad_str = zen_settings['variables']['indentation'] * pad\n\telse:\n\t\tpad_str = pad\n\t\t\n\tnl = get_newline()\n\tlines = text.split(nl)\n\tresult = result + lines[0]\n\tfor line in lines[1:]:\n\t\tresult += nl + pad_str + line\n\t\t\n\treturn result","def str (self, max_len_first, max_len_following=0) :\r\n\r\n\t\t## This version indents continuation lines by 1 space\r\n\t\tif not max_len_following == 0 :\r\n\t\t\tmax_len_following -= 1\r\n\t\t\r\n\t\tresult = tokenizer.join_tokens(self.tokens, max_len_first, max_len_following)\r\n\t\tresult[1:] = [ (\" \" + r) for r in result[1:] ]\r\n\r\n\t\treturn [result]","def tabing_tool(code):\n for i, line in enumerate(code):\n code[i] = ' '*4 + line\n return code","def fill_with_spaces(line: string, width: int) -> string:\n size = len(line)\n spaces_left = width - size\n return line + (' ' * spaces_left)","def _spacer(self, msg):\n msg = str(msg)\n msg_len = len(msg)\n if msg_len == 1:\n print(\" \", end=\"\")\n elif msg_len == 2:\n print(\" \", end=\"\")","def add_padding(text1: str) -> str:\n\n pad_len = 8 - (len(text1) % 8)\n return text1 + (pad_len * '\\0')","def truncate_pad(line, num_steps, padding_token):\n if len(line) > num_steps:\n return line[:num_steps] # Truncate\n return line + [padding_token] * (num_steps - len(line)) # Pad","def truncate_pad(line, num_steps, padding_token):\n if len(line) > num_steps:\n return line[:num_steps] # Truncate\n return line + [padding_token] * (num_steps - len(line)) # Pad","def truncate_pad(line, num_steps, padding_token):\n if len(line) > num_steps:\n return line[:num_steps] # Truncate\n return line + [padding_token] * (num_steps - len(line)) # Pad","def align_tokens(tokens, target_token_index):\n seq_len = self.seq_len - 2\n if len(tokens) > seq_len:\n start_index = max(0, int(target_token_index - seq_len / 2 + middle_shift))\n start_index = min(start_index, len(tokens) - seq_len)\n while tokens[start_index].startswith('#') and start_index + seq_len > target_token_index + 1:\n start_index -= 1\n start_index = max(0, start_index)\n tokens = tokens[start_index : start_index + seq_len]\n target_token_index -= start_index\n tokens = ['[CLS]', ] + tokens + ['[SEP]', ]\n target_token_index += 1\n return tokens, target_token_index","def get_pad1(n):\n if n < 10:\n return \" \"\n if n < 100:\n return \" \"\n if n < 1000:\n return \" \"\n return \"\"","def wrapspace(text, token):\n\n # Wildcards have no whitespace. Need special case since * is also multiply which does have whitespace.\n if token in [\"*\"] and (not text or text.endswith((\" \", \"(\"))):\n return token\n\n # Operator whitespace\n if Token.isoperator(token) or Token.islogicseparator(token) or token.lower() in [\"in\"]:\n return f\" {token} \" if not text.endswith(\" \") else f\"{token} \"\n\n # Comma whitespace\n if Token.isseparator(token):\n return f\"{token} \"\n\n # No whitespace if any of the following is True\n if not text or text.endswith((\" \", \"(\", \"[\")) or token in [\"(\", \"[\", \")\", \"]\"] or token.startswith(\".\"):\n return token\n\n # Default is to add leading whitespace\n return f\" {token}\"","def add_padding(self, text):\n\n for word in text.split(' '):\n # 5 character blocks added straight\n if len(word) == 5:\n self.output += word + ' '\n # calling the helper method to fill the blocks\n elif len(word) < 5:\n self._helper(word)\n # split the block up into 5 letter chunks\n elif len(word) > 5:\n block = ''\n for letter in word:\n block += letter\n if len(block) == 5:\n # append the chunk to output\n self.output += block + ' '\n block = ''\n self._helper(block)\n\n return self.output.upper()","def indent(text, n=4):\n if not text:\n return \"\"\n i = \" \" * n\n return i + text.replace(\"\\n\", \"\\n\" + i)","def _newLine(self, usePos = True):","def pad_tokens(x, max_length, pad_token_id,\n truncate_from=\"left\",\n pad_from=\"left\"):\n assert truncate_from in (\"left\", \"right\")\n assert pad_from in (\"left\", \"right\")\n if len(x) > max_length:\n if truncate_from == \"left\":\n return x[-max_length:]\n else:\n return x[:max_length]\n elif len(x) < max_length:\n padding = [pad_token_id] * (max_length - len(x))\n if pad_from == \"left\":\n return padding + x\n else:\n return x + padding\n else:\n return x","def _createrow(self, columns):\r\n # Each cell is a column padded to len(self)\r\n cells = []\r\n \r\n for col in columns:\r\n # left-justify and pad to len(self)\r\n cells.append(col.ljust(len(self)))\r\n \r\n # Join all the cells into one row str, with ' | ' as the separator\r\n return ' | '.join(cells)","def getterminator(self):\n if self.multiline:\n return \"%s.%s\" % (CRLF,CRLF)\n return CRLF","def _pretty_table_line(self, items):\n padded_strings = []\n for i, s in enumerate(items):\n padding_value = self._padding_values[i]\n padded_strings.append('{:<{}s}'.format(str(s), padding_value))\n return \" \" + \"| \".join(padded_strings)","def _pad_shorter(sequence: str) -> str:\n return sequence.ljust(3, \"X\")","def _collapse_leading_ws(header, txt):\n if header.lower() == 'description': # preserve newlines\n return '\\n'.join([x[8:] if x.startswith(' ' * 8) else x\n for x in txt.strip().splitlines()])\n else:\n return ' '.join([x.strip() for x in txt.splitlines()])","def add_padding(self):\n pad_len = 8 - (len(self.text) % 8)\n self.text += pad_len * chr(pad_len)","def insert_padded(string: str) -> None:\n around = actions.user.surrounding_text()\n if around:\n if around.char_before != \" \":\n insert(\" \")\n insert(string)\n if around.char_after != \" \":\n insert(\" \")\n else:\n insert(f\" {string} \")","def WordWrap(cmd, linelen=80):\n indent = cmd.index(\"(\")+1\n out = []\n first = True\n x = re.compile(\"^(.{,%d})\\0\" % (linelen-indent,))\n while True:\n if not first:\n out.append(\" \" * indent)\n first = False\n m = x.search(cmd)\n if not m:\n parts = cmd.split(\"\\0\", 1)\n out.append(parts[0]+\"\\n\")\n if len(parts) == 1:\n break\n else:\n cmd = parts[1]\n continue\n out.append(m.group(1)+\"\\n\")\n cmd = cmd[m.end():]\n\n return \"\".join(out).replace(\"\\0\", \" \").rstrip(\"\\n\")","def test_space_at_the_end():\n line = \"n\" * 79 + \" \"\n print \"--%s--\" % wrap_line(line)\n assert wrap_line(line) == \"n\" * 79","def insert_newline():\r\n insert_char(\"\\n\")","def delimit(self):\n pass","def _justifyText(text):\n chunks = text.split()\n line = []\n lineLength = 0\n for chunk in chunks:\n lineLength += len(chunk) + 1\n if lineLength <= 73:\n line.append(chunk)\n continue\n else:\n print('''{:5}{:73}{}'''.format(\"|\", \" \".join(line), \"|\"))\n del line[:]\n line.append(chunk)\n lineLength = len(chunk) + 1\n print('''{:5}{:73}{}'''.format(\"|\", \" \".join(line), \"|\"))","def left_justify_string(keyword, value):\n return '%s' % keyword .ljust(40, \".\") + \": \" + '%s\\n' % value","def add_spaces(text):\n return \" \".join(text)","def insert_key_padded(key: str) -> None:\n around = actions.user.surrounding_text()\n if not around or around.char_before != \" \":\n insert(\" \")\n try:\n actions.key(key)\n except ValueError:\n # HACK: To insert \"keys\" like `->`\n actions.insert(key)\n if not around or around.char_after != \" \":\n insert(\" \")","def _addIndent(self, block, count=1):\n return re.compile(r\"^((?!$))\", re.M).sub(\" \" * count, block)","def pad_sentence_batch(sentence_batch):\n max_sentence = max([len(sentence) for sentence in sentence_batch])\n return [sentence + [CODES['<PAD>']] * (max_sentence - len(sentence))\n for sentence in sentence_batch]","def get_pad2(s1, s2):\n return \" \" * (40 - len(s1) - len(s2))","def get_pad(self, n):\n pad = \"\"\n for i in range(0, n):\n pad += \" \"\n return pad","def _insert_leading_whitespace(self, line_list):\n if self._leading_whitespace:\n line_list[0] = '{0}{1}'.format(\n self._leading_whitespace, line_list[0]\n )\n\n return line_list","def lf(self):\n self._write('\\n')","def _despace(statement):\n return re.sub(r' +', ' ', statement)","def cat(cls, sep):\n return lambda x,y: (len(x)<10000) and \"%s%s%s\" % (x, sep, y) or x","def adjustl(self):\n s = self._val.lstrip()\n pad_str = self.padding(len(s))\n return s + pad_str","def _filler(self, char, amount):\n if not isinstance(char, ANSIString):\n line = char * amount\n return ANSIString(\n char * amount,\n code_indexes=[],\n char_indexes=list(range(0, len(line))),\n clean_string=char,\n )\n try:\n start = char._code_indexes[0]\n except IndexError:\n start = None\n end = char._char_indexes[0]\n prefix = char._raw_string[start:end]\n postfix = char._raw_string[end + 1 :]\n line = char._clean_string * amount\n code_indexes = [i for i in range(0, len(prefix))]\n length = len(prefix) + len(line)\n code_indexes.extend([i for i in range(length, length + len(postfix))])\n char_indexes = self._shifter(list(range(0, len(line))), len(prefix))\n raw_string = prefix + line + postfix\n return ANSIString(\n raw_string, clean_string=line, char_indexes=char_indexes, code_indexes=code_indexes\n )","def to_whitespace(self, empty=False, strip_nl=False, strip_comments=False):\n if strip_nl and self.type == tokenize.NL:\n self.string = \"\"\n return\n if strip_comments and self.type == tokenize.COMMENT:\n self.string = \"\"\n return\n if self.type in ignored_types_set:\n return\n if empty:\n self.string = \"\"\n else:\n self.string = \" \" * len(self.token_tuple[1])","def space_delimited(cls, *columns: str) -> \"SpaceDelimitedTextPattern\":\n return jsii.sinvoke(cls, \"spaceDelimited\", [*columns])","def indent(text, first_line=True, n=1, width=4):\n lines = text.split(\"\\n\")\n if not first_line:\n first = lines[0]\n lines = lines[1:]\n\n spaces = \" \" * (width * n)\n lines2 = [spaces + x for x in lines]\n\n if not first_line:\n lines2.insert(0, first)\n\n indented = \"\\n\".join(lines2)\n\n return indented","def r_pad(arg, length):\n if length <= len(arg):\n return arg\n else:\n return arg + \" \" * (length - len(arg))","def test_blank_last_line():\n column_1 = Column(\"Col 1\", width=10)\n tc = TableCreator([column_1])\n\n row_data = ['my line\\n\\n']\n row = tc.generate_row(row_data=row_data, is_header=False)\n assert row == ('my line \\n'\n ' ')\n\n row_data = ['\\n']\n row = tc.generate_row(row_data=row_data, is_header=False)\n assert row == ' '\n\n row_data = ['']\n row = tc.generate_row(row_data=row_data, is_header=False)\n assert row == ' '","def add_line(self):\n #N_spaces = message.count(' ') # From both sides\n banner = 40\n words = [self.your_string]\n word_sum = sum(len(i) for i in words)\n margin1 = int(banner/5)*\"=\"\n margi1_len = len(margin1)\n margin2 = (banner-(margi1_len+word_sum+2))*\"=\"\n if len(margin1+self.your_string+margin2) < banner:\n \"\"\"\n Here for simple one line sentence we add\n directly the margins with the self.your_string\n \"\"\"\n print(banner*\"=\")\n print(f\"\"\"{margin1} {self.your_string} {margin2}\"\"\")\n print(banner*\"=\")\n else:\n \"\"\"\n Here we check the number of words and reset the list and\n spaces everytime we go to a new line until the self.your_string\n is finished.\n \"\"\"\n print(banner*\"=\")\n wordsx = self.your_string.split()\n xr = 4 # alignment added later (adjusted manually)\n i = 0\n spacex = 0\n listwords = []\n while i < len(wordsx):\n\n listwords.append(wordsx[i])\n if sum(len(i) for i in listwords) + spacex < banner-xr:\n print(wordsx[i], end = \" \")\n spacex = spacex +1\n\n else:\n print(wordsx[i])\n listwords = []\n spacex = 0\n\n i = i +1\n\n print(\"\\n\", end= \"\")\n print(banner*\"=\")","def pad(msg):\n return msg + (BLOCK_SIZE - len(msg)) * PADDING","def rehydrate_text(self, next_token):\n prefix_text = \"\"\n main_text = next_token.token_text.replace(\n InlineHelper.backspace_character, \"\"\n ).replace(\"\\x08\", \"\")\n\n print(\n \">>rehydrate_text>>\" + main_text.replace(\"\\a\", \"\\\\a\").replace(\"\\n\", \"\\\\n\")\n )\n main_text = self.resolve_replacement_markers(main_text)\n print(\n \"<<rehydrate_text>>\" + main_text.replace(\"\\a\", \"\\\\a\").replace(\"\\n\", \"\\\\n\")\n )\n\n print(\n \"<<leading_whitespace>>\"\n + next_token.extracted_whitespace.replace(\"\\a\", \"\\\\a\")\n .replace(\"\\n\", \"\\\\n\")\n .replace(\"\\x03\", \"\\\\x03\")\n )\n leading_whitespace = self.resolve_replacement_markers(\n next_token.extracted_whitespace\n )\n print(\n \"<<leading_whitespace>>\"\n + leading_whitespace.replace(\"\\a\", \"\\\\a\")\n .replace(\"\\n\", \"\\\\n\")\n .replace(\"\\x03\", \"\\\\x03\")\n )\n if self.block_stack:\n if (\n self.block_stack[-1].token_name\n == MarkdownToken.token_indented_code_block\n ):\n main_text = self.reconstitute_indented_text(\n main_text,\n self.block_stack[-1].extracted_whitespace,\n self.block_stack[-1].indented_whitespace,\n leading_whitespace,\n )\n prefix_text = \"\"\n leading_whitespace = \"\"\n elif self.block_stack[-1].token_name == MarkdownToken.token_html_block:\n main_text += \"\\n\"\n elif self.block_stack[-1].token_name == MarkdownToken.token_paragraph:\n if \"\\n\" in main_text:\n split_token_text = main_text.split(\"\\n\")\n split_parent_whitespace_text = self.block_stack[\n -1\n ].extracted_whitespace.split(\"\\n\")\n print(\n \">>split_token_text>>\"\n + str(split_token_text)\n .replace(\"\\n\", \"\\\\n\")\n .replace(\"\\t\", \"\\\\t\")\n )\n print(\n \">>split_parent_whitespace_text>>\"\n + str(split_parent_whitespace_text)\n .replace(\"\\n\", \"\\\\n\")\n .replace(\"\\t\", \"\\\\t\")\n )\n\n # TODO never incrementing?\n parent_rehydrate_index = self.block_stack[-1].rehydrate_index\n\n rejoined_token_text = []\n for iterator in enumerate(split_token_text, start=0):\n print(\">>\" + str(iterator))\n if iterator[0] == 0:\n joined_text = iterator[1]\n else:\n joined_text = (\n split_parent_whitespace_text[\n parent_rehydrate_index + iterator[0]\n ]\n + iterator[1]\n )\n rejoined_token_text.append(joined_text)\n split_token_text = rejoined_token_text\n\n if next_token.end_whitespace:\n split_end_whitespace_text = next_token.end_whitespace.split(\n \"\\n\"\n )\n print(\n \">>split_end_whitespace_text>>\"\n + str(split_end_whitespace_text)\n .replace(\"\\n\", \"\\\\n\")\n .replace(\"\\t\", \"\\\\t\")\n )\n assert len(split_token_text) == len(split_end_whitespace_text)\n\n joined_token_text = []\n for iterator in enumerate(split_token_text):\n print(\">>\" + str(iterator))\n joined_text = (\n iterator[1] + split_end_whitespace_text[iterator[0]]\n )\n joined_token_text.append(joined_text)\n split_token_text = joined_token_text\n main_text = \"\\n\".join(split_token_text)\n elif self.block_stack[-1].token_name == MarkdownToken.token_setext_heading:\n if \"\\n\" in main_text:\n split_token_text = main_text.split(\"\\n\")\n split_parent_whitespace_text = next_token.end_whitespace.split(\"\\n\")\n print(\n \">>split_token_text>>\"\n + str(split_token_text)\n .replace(\"\\n\", \"\\\\n\")\n .replace(\"\\t\", \"\\\\t\")\n )\n print(\n \">>split_parent_whitespace_text>>\"\n + str(split_parent_whitespace_text)\n .replace(\"\\n\", \"\\\\n\")\n .replace(\"\\t\", \"\\\\t\")\n )\n\n # TODO never incrementing?\n parent_rehydrate_index = 0 # self.block_stack[-1].rehydrate_index\n\n rejoined_token_text = []\n for iterator in enumerate(split_token_text, start=0):\n print(\">>iterator=\" + str(iterator))\n split_setext_text = []\n ws_prefix_text = \"\"\n ws_suffix_text = \"\"\n if split_parent_whitespace_text[iterator[0]]:\n split_setext_text = split_parent_whitespace_text[\n iterator[0]\n ].split(\"\\x02\")\n print(\">>split_setext_text=\" + str(split_setext_text))\n if len(split_setext_text) == 1:\n if iterator[0] == 0:\n ws_suffix_text = split_setext_text[0]\n else:\n ws_prefix_text = split_setext_text[0]\n else:\n assert len(split_setext_text) == 2\n ws_prefix_text = split_setext_text[0]\n ws_suffix_text = split_setext_text[1]\n\n joined_text = ws_prefix_text + iterator[1] + ws_suffix_text\n rejoined_token_text.append(joined_text)\n\n print(\">>rejoined_token_text=\" + str(rejoined_token_text))\n main_text = \"\\n\".join(rejoined_token_text)\n return prefix_text + leading_whitespace + main_text","def __split_seq(self, sequence):\n seq = copy.copy(sequence)\n result = \"\"\n while len(seq) > self._max_len:\n if seq[self._max_len] == \"\":\n result += seq[:self._max_len] + \"\\n\"\n seq = seq[self._max_len:]\n else:\n whitespace_index = self._max_len - seq[:self._max_len][::-1].find(\" \")\n result += seq[:whitespace_index] + \"\\n\"\n seq = seq[whitespace_index:]\n result += seq\n return result","def rehydrate_paragraph_end(self, next_token):\n assert next_token\n top_stack_token = self.block_stack[-1]\n del self.block_stack[-1]\n return top_stack_token.final_whitespace + \"\\n\"","def sep(s):\n return ' '+s if s else s","def wordwrap(value, arg=80):\n\treturn \"\\n\".join(textwrap.wrap(value, int(arg)))","def get_orion_space_string(self) -> str:","def line_blank(record):\n record.colon = record.space = record.sep = record.levelname \\\n = record.filename = record.lineno = record.threadName \\\n = record.processName = ''\n return record","def space():\n print(' ', end='')","def padding(input_value, value):\n padding_value = str(input_value)\n for i in range(value - len(str(input_value))):\n padding_value += \" \"\n return padding_value","def padding(self, n):\n if n < self._length: # pad with blanks\n k = self._length - n\n pad_str = \" \" * k\n else:\n pad_str = \"\"\n\n return pad_str","def _pad_sentence_length(self, sentence):\n if len(sentence) > self.pad_sentence_length:\n sentence = sentence[:self.pad_sentence_length]\n sentence[self.pad_sentence_length-1] = \"@EOS@\"\n elif len(sentence) < self.pad_sentence_length:\n sentence.extend([\"@PAD@\"] * (self.pad_sentence_length - len(sentence)))\n return sentence","def Fill(self, line):\n self._blank = True\n for word in line.split():\n if not self._fill:\n self._fill = self._indent[self._level] - 1\n self._out.write(' ' * self._fill)\n n = self._attr.PrintWidth(word)\n if self._fill + n + 1 >= self._width and not self._ignore_width:\n self._out.write('\\n')\n self._fill = self._indent[self._level]\n self._out.write(' ' * self._fill)\n else:\n self._ignore_width = False\n if self._fill:\n self._fill += 1\n self._out.write(' ')\n self._fill += n\n self._out.write(word)","def indent(text, count=1, prefix=\" \"):\n lines = text.split(\"\\n\")\n return \"\\n\".join(\"{}{}\".format(prefix * count, line)\n for line in lines)","def finalize(self):\n if self.whitespace:\n return Token('', self.whitespace,\n typ=Token.WHITESPACE, position=self.position)\n return None","def spacify(string):\n return \" \" + \" \".join(string.splitlines(True))","def insertNewlines(text, lineLength):\r\n lenCtr = 0\r\n this = []\r\n \r\n # convert entire text to a list of words\r\n words = text.split()\r\n \r\n # get a length of all the word\r\n for each in words[:]:\r\n lenCtr += len(each) + 1 # word length + whitespace\r\n this.append(each) # add word to this line\r\n words.remove(each) # remove word from remaining text\r\n print this,\r\n print words,\r\n print lenCtr\r\n if lenCtr >= lineLength:\r\n # insert \\n when lineLength is reached\r\n this.append('\\n')\r\n break\r\n # if itarable is exhausted, just return entire text\r\n else:\r\n return ' '.join(words)\r\n # remaining text\r\n text = ' '.join(words)\r\n return ' '.join(this) + insertNewlines(text, lineLength)","def align_strings(strings, header=''):\n spaces = [len(l)-len(l.lstrip()) for l in strings.data if l]\n min_spaces = min(spaces) if spaces else 0\n if min_spaces > 0 or header:\n for index in range(len(strings.data)):\n strings.data[index] = header + strings.data[index][min_spaces:]","def _format_line(line: str, n: int, padding: int) -> str:\n return ' {dim}{n}{reset}: {line}'.format(dim=Style.DIM,\n n=str(n + 1).zfill(padding),\n line=line,\n reset=Style.RESET_ALL)","def indent(value):\n return \" \" + value","def _pad_horizontally(self, chars_written):\n if chars_written >= self.width:\n return\n\n extra = self.width - chars_written\n self.buf += ' ' * extra","def __indent_text_block(text):\n lines = text.splitlines()\n if len(lines) > 1:\n out = lines[0] + \"\\r\\n\"\n for i in range(1, len(lines)-1):\n out = out + \" \" + lines[i] + \"\\r\\n\"\n out = out + \" \" + lines[-1]\n return out\n return text","def pad_delimiters(string1, number, delimiter=',', slen=None, ):\n current_num = string1.count(delimiter)\n num_to_add = number - current_num\n \n curlen = len(string1)\n \n if num_to_add > 0:\n if slen is not None:\n len_to_add = slen - curlen\n \n spacing = int(len_to_add / num_to_add)\n xtra = len_to_add % num_to_add\n\n s1 = (\"%\" + str(spacing) + \"s\") % delimiter\n s1 = s1 * num_to_add + \" \" * xtra\n string1 += s1\n else:\n string1 += delimiter * num_to_add\n return string1","def pad_chars(text, encoding=None, null_terminate=True, pad_to_multiple_of=4):\n if pad_to_multiple_of < 0 or not isinstance(pad_to_multiple_of, int):\n raise ValueError(\"pad must be an integer greater than zero.\")\n if encoding is not None:\n encoded = text.encode(encoding) + (b\"\\0\" if null_terminate else b\"\")\n else:\n encoded = text + (\"\\0\" if null_terminate else \"\")\n pad = b\"\\0\" if encoding is not None else \"\\0\"\n while len(encoded) % pad_to_multiple_of != 0:\n encoded += pad\n return encoded","def feed(self, token, test_newline=True):\n if test_newline:\n newlines = token.count(self.newline_char)\n if newlines:\n self.line += newlines\n self.line_start_pos = self.char_pos + token.rindex(self.newline_char) + 1\n\n self.char_pos += len(token)\n self.column = self.char_pos - self.line_start_pos + 1","def __Pad(self, data):\n pad = self.block_size - len(data) % self.block_size\n return data + pad * chr(pad)","def fix_whitespace(lines: Sequence[str], eol: str, ends_with_eol: bool) -> str:\n lines = _strip(lines)\n lines = [i.expandtabs(4) for i in lines]\n result = eol.join(lines)\n if ends_with_eol:\n result += eol\n return result","def _commandline_join(self, tokens):\r\n commands = filter(None, map(str, tokens))\r\n return self._command_delimiter.join(commands).strip()","def _commandline_join(self, tokens):\r\n commands = filter(None, map(str, tokens))\r\n return self._command_delimiter.join(commands).strip()","def _commandline_join(self, tokens):\r\n commands = filter(None, map(str, tokens))\r\n return self._command_delimiter.join(commands).strip()","def _padboth(width, s):\n fmt = \"{0:^%ds}\" % width\n return fmt.format(s)","def space(n):\n rstr = \" \" * 4 * n\n return rstr","def pad_encoded_text(self, encoded_text):\n\n\t\textra_padding = 8 - len(encoded_text) % 8#calculmaos cuanto falta por agregar\n\t\tfor i in range(extra_padding):\n\t\t\tencoded_text += \"0\"\n\n\t\tpadded_info = \"{0:08b}\".format(extra_padding)#le agregamos una informacion adicionar la cual utilizaremos despues al comprimir para saber cuantos 0 le agregamos y despues poder eliminarlos\n\t\tencoded_text = padded_info + encoded_text\n\t\treturn encoded_text","def ljust(self, width, fillchar, _difference):\n return self + self._filler(fillchar, _difference)","def pad(text, width, pad_character=\" \"):\n\n length = len(text)\n if width < 0 and length < -width:\n return text + (-width - length) * pad_character\n elif width > 0 and length < width:\n return (width - length) * pad_character + text\n else:\n return text","def __pad(self,buf):\n return Utils.pad(buf,self.com.granularity)","def hangingIndent(msg, numCols):\r\n\tinsertPoint = numCols\r\n\twhile insertPoint < len(msg):\r\n\t\tmsg = msg[:insertPoint] + \"\".center(INDENT_SIZE) + msg[insertPoint:]\r\n\t\tinsertPoint += numCols\r\n\t\r\n\treturn msg","def _reset_leading_whitespace(self):\n self._leading_whitespace = ''","def get_indent(op):\n ret = \"\"\n for ii in range(op):\n # Would tab be better?\n ret += \" \"\n return ret","def fill(text,width=60):\r\n pars = [textwrap.fill(text,width) for text in text.split('\\n')]\r\n return '\\n'.join(pars)","def dumb_formatter(out, text, left, right = None):\n if right == None:\n (right, line_length) = bigsh.pp.get_terminal_size()\n if right - 20 > left: # XXX needs work\n right = right - 20\n right = min(right, 120)\n\n left_indent = ' ' * left\n out_len = left\n out_line = left_indent\n\n for line in text.split('\\n'):\n if len(line) == 0:\n if out_len > left:\n out.append(out_line)\n out_len = left\n out_line = left_indent\n out.append('')\n elif line[0] == ' ' or line[0] == '\\t': # leading spaces\n if out_len > left:\n out.append(out_line)\n out_len = left\n out_line = left_indent\n out.append( left_indent + line )\n else: # text formatting\n\n for word in line.split():\n sep = ' '\n if word.endswith('.'):\n sep = ' '\n if len(word) + out_len + len(sep) > right:\n if out_len > left:\n out.append(out_line)\n out_len = left + len(word) + len(sep)\n out_line = left_indent + word + sep\n else:\n out_line += word + sep\n out_len += len(sep) + len(word)\n if out_len > left:\n out.append(out_line)","def pretty(self):\n\t\tif not self.content.endswith('\\n'):\n\t\t\tself.content += '\\n'","def pad(plain_text):\n number_of_bytes_to_pad = block_size - len(plain_text) % block_size\n ascii_string = chr(number_of_bytes_to_pad)\n padding_str = number_of_bytes_to_pad * ascii_string\n padded_plain_text = plain_text + padding_str\n return padded_plain_text","def newBuffer():\n buffer = []\n for i in range(0,8):\n buffer.append(\" \")\n return buffer","def separeIndent(self,line):\n p=0\n while p<len(line) and line[p] in string.whitespace:\n p=p+1\n rest=line[p:]\n return line[:p],rest"],"string":"[\n \"def _output_padding_line(self):\\n for i in range(self.num_new_columns):\\n self._write_column(self.new_columns[i], '|')\\n self.buf += ' '\\n\\n self._pad_horizontally(self.num_new_columns * 2)\",\n \"def rehydrate_blank_line(cls, next_token):\\n return next_token.extracted_whitespace + \\\"\\\\n\\\"\",\n \"def rehydrate_thematic_break(cls, next_token):\\n return next_token.extracted_whitespace + next_token.rest_of_line + \\\"\\\\n\\\"\",\n \"def mywrap(text):\\n text = text.replace(\\\"\\\\n\\\\n\\\", \\\"\\\\n\\\").replace(\\\"\\\\n\\\", \\\"\\\\n \\\").rstrip()\\n return text\",\n \"def _padding_line(self):\\n if self.state != GraphState.COMMIT:\\n self._next_line()\\n return\\n\\n # Output the row containing this commit\\n # Iterate up to and including self.num_columns, since the current commit\\n # may not be in any of the existing columns. (This happens when the\\n # current commit doesn't have any children that we have already\\n # processed.)\\n for i in range(self.num_columns):\\n col = self.columns[i]\\n self._write_column(col, '|')\\n if col.commit == self.commit and self.num_parents > 2:\\n self.buf += ' ' * (self.num_parents - 2) * 2\\n else:\\n self.buf += ' '\\n\\n self._pad_horizontally(self.num_columns)\\n\\n # Update self.prev_state since we have output a padding line\\n self.prev_state = GraphState.PADDING\",\n \"def justify_token(tok, col_width):\\n get_len = tools.display_len if PY3 else len\\n tok_len = get_len(tok)\\n diff_len = tok_len - len(tok) if PY3 else 0\\n\\n cols = (int(math.ceil(float(tok_len) / col_width))\\n if col_width < tok_len + 4 else 1)\\n\\n if cols > 1:\\n return tok.ljust((col_width * cols) + (4 * cols) - diff_len)\\n else:\\n return tok.ljust(col_width + 4 - diff_len)\",\n \"def join(self, tokens):\\n if self.chars:\\n joiner = ''\\n else:\\n joiner = ' '\\n return joiner.join(tokens)\",\n \"def _newline(self):\\n if prettyprint:\\n return '\\\\n' + self._indent_spaces()\\n else:\\n return ''\",\n \"def full_tokens(tokens):\\n target_length = roundup2(len(tokens))\\n padding_length = target_length - len(tokens)\\n tokens = [PADDING_TOKEN] * padding_length + tokens\\n return tokens\",\n \"def pad_string(text, pad):\\n\\tpad_str = ''\\n\\tresult = ''\\n\\tif (type(pad) is int):\\n\\t\\tpad_str = zen_settings['variables']['indentation'] * pad\\n\\telse:\\n\\t\\tpad_str = pad\\n\\t\\t\\n\\tnl = get_newline()\\n\\tlines = text.split(nl)\\n\\tresult = result + lines[0]\\n\\tfor line in lines[1:]:\\n\\t\\tresult += nl + pad_str + line\\n\\t\\t\\n\\treturn result\",\n \"def str (self, max_len_first, max_len_following=0) :\\r\\n\\r\\n\\t\\t## This version indents continuation lines by 1 space\\r\\n\\t\\tif not max_len_following == 0 :\\r\\n\\t\\t\\tmax_len_following -= 1\\r\\n\\t\\t\\r\\n\\t\\tresult = tokenizer.join_tokens(self.tokens, max_len_first, max_len_following)\\r\\n\\t\\tresult[1:] = [ (\\\" \\\" + r) for r in result[1:] ]\\r\\n\\r\\n\\t\\treturn [result]\",\n \"def tabing_tool(code):\\n for i, line in enumerate(code):\\n code[i] = ' '*4 + line\\n return code\",\n \"def fill_with_spaces(line: string, width: int) -> string:\\n size = len(line)\\n spaces_left = width - size\\n return line + (' ' * spaces_left)\",\n \"def _spacer(self, msg):\\n msg = str(msg)\\n msg_len = len(msg)\\n if msg_len == 1:\\n print(\\\" \\\", end=\\\"\\\")\\n elif msg_len == 2:\\n print(\\\" \\\", end=\\\"\\\")\",\n \"def add_padding(text1: str) -> str:\\n\\n pad_len = 8 - (len(text1) % 8)\\n return text1 + (pad_len * '\\\\0')\",\n \"def truncate_pad(line, num_steps, padding_token):\\n if len(line) > num_steps:\\n return line[:num_steps] # Truncate\\n return line + [padding_token] * (num_steps - len(line)) # Pad\",\n \"def truncate_pad(line, num_steps, padding_token):\\n if len(line) > num_steps:\\n return line[:num_steps] # Truncate\\n return line + [padding_token] * (num_steps - len(line)) # Pad\",\n \"def truncate_pad(line, num_steps, padding_token):\\n if len(line) > num_steps:\\n return line[:num_steps] # Truncate\\n return line + [padding_token] * (num_steps - len(line)) # Pad\",\n \"def align_tokens(tokens, target_token_index):\\n seq_len = self.seq_len - 2\\n if len(tokens) > seq_len:\\n start_index = max(0, int(target_token_index - seq_len / 2 + middle_shift))\\n start_index = min(start_index, len(tokens) - seq_len)\\n while tokens[start_index].startswith('#') and start_index + seq_len > target_token_index + 1:\\n start_index -= 1\\n start_index = max(0, start_index)\\n tokens = tokens[start_index : start_index + seq_len]\\n target_token_index -= start_index\\n tokens = ['[CLS]', ] + tokens + ['[SEP]', ]\\n target_token_index += 1\\n return tokens, target_token_index\",\n \"def get_pad1(n):\\n if n < 10:\\n return \\\" \\\"\\n if n < 100:\\n return \\\" \\\"\\n if n < 1000:\\n return \\\" \\\"\\n return \\\"\\\"\",\n \"def wrapspace(text, token):\\n\\n # Wildcards have no whitespace. Need special case since * is also multiply which does have whitespace.\\n if token in [\\\"*\\\"] and (not text or text.endswith((\\\" \\\", \\\"(\\\"))):\\n return token\\n\\n # Operator whitespace\\n if Token.isoperator(token) or Token.islogicseparator(token) or token.lower() in [\\\"in\\\"]:\\n return f\\\" {token} \\\" if not text.endswith(\\\" \\\") else f\\\"{token} \\\"\\n\\n # Comma whitespace\\n if Token.isseparator(token):\\n return f\\\"{token} \\\"\\n\\n # No whitespace if any of the following is True\\n if not text or text.endswith((\\\" \\\", \\\"(\\\", \\\"[\\\")) or token in [\\\"(\\\", \\\"[\\\", \\\")\\\", \\\"]\\\"] or token.startswith(\\\".\\\"):\\n return token\\n\\n # Default is to add leading whitespace\\n return f\\\" {token}\\\"\",\n \"def add_padding(self, text):\\n\\n for word in text.split(' '):\\n # 5 character blocks added straight\\n if len(word) == 5:\\n self.output += word + ' '\\n # calling the helper method to fill the blocks\\n elif len(word) < 5:\\n self._helper(word)\\n # split the block up into 5 letter chunks\\n elif len(word) > 5:\\n block = ''\\n for letter in word:\\n block += letter\\n if len(block) == 5:\\n # append the chunk to output\\n self.output += block + ' '\\n block = ''\\n self._helper(block)\\n\\n return self.output.upper()\",\n \"def indent(text, n=4):\\n if not text:\\n return \\\"\\\"\\n i = \\\" \\\" * n\\n return i + text.replace(\\\"\\\\n\\\", \\\"\\\\n\\\" + i)\",\n \"def _newLine(self, usePos = True):\",\n \"def pad_tokens(x, max_length, pad_token_id,\\n truncate_from=\\\"left\\\",\\n pad_from=\\\"left\\\"):\\n assert truncate_from in (\\\"left\\\", \\\"right\\\")\\n assert pad_from in (\\\"left\\\", \\\"right\\\")\\n if len(x) > max_length:\\n if truncate_from == \\\"left\\\":\\n return x[-max_length:]\\n else:\\n return x[:max_length]\\n elif len(x) < max_length:\\n padding = [pad_token_id] * (max_length - len(x))\\n if pad_from == \\\"left\\\":\\n return padding + x\\n else:\\n return x + padding\\n else:\\n return x\",\n \"def _createrow(self, columns):\\r\\n # Each cell is a column padded to len(self)\\r\\n cells = []\\r\\n \\r\\n for col in columns:\\r\\n # left-justify and pad to len(self)\\r\\n cells.append(col.ljust(len(self)))\\r\\n \\r\\n # Join all the cells into one row str, with ' | ' as the separator\\r\\n return ' | '.join(cells)\",\n \"def getterminator(self):\\n if self.multiline:\\n return \\\"%s.%s\\\" % (CRLF,CRLF)\\n return CRLF\",\n \"def _pretty_table_line(self, items):\\n padded_strings = []\\n for i, s in enumerate(items):\\n padding_value = self._padding_values[i]\\n padded_strings.append('{:<{}s}'.format(str(s), padding_value))\\n return \\\" \\\" + \\\"| \\\".join(padded_strings)\",\n \"def _pad_shorter(sequence: str) -> str:\\n return sequence.ljust(3, \\\"X\\\")\",\n \"def _collapse_leading_ws(header, txt):\\n if header.lower() == 'description': # preserve newlines\\n return '\\\\n'.join([x[8:] if x.startswith(' ' * 8) else x\\n for x in txt.strip().splitlines()])\\n else:\\n return ' '.join([x.strip() for x in txt.splitlines()])\",\n \"def add_padding(self):\\n pad_len = 8 - (len(self.text) % 8)\\n self.text += pad_len * chr(pad_len)\",\n \"def insert_padded(string: str) -> None:\\n around = actions.user.surrounding_text()\\n if around:\\n if around.char_before != \\\" \\\":\\n insert(\\\" \\\")\\n insert(string)\\n if around.char_after != \\\" \\\":\\n insert(\\\" \\\")\\n else:\\n insert(f\\\" {string} \\\")\",\n \"def WordWrap(cmd, linelen=80):\\n indent = cmd.index(\\\"(\\\")+1\\n out = []\\n first = True\\n x = re.compile(\\\"^(.{,%d})\\\\0\\\" % (linelen-indent,))\\n while True:\\n if not first:\\n out.append(\\\" \\\" * indent)\\n first = False\\n m = x.search(cmd)\\n if not m:\\n parts = cmd.split(\\\"\\\\0\\\", 1)\\n out.append(parts[0]+\\\"\\\\n\\\")\\n if len(parts) == 1:\\n break\\n else:\\n cmd = parts[1]\\n continue\\n out.append(m.group(1)+\\\"\\\\n\\\")\\n cmd = cmd[m.end():]\\n\\n return \\\"\\\".join(out).replace(\\\"\\\\0\\\", \\\" \\\").rstrip(\\\"\\\\n\\\")\",\n \"def test_space_at_the_end():\\n line = \\\"n\\\" * 79 + \\\" \\\"\\n print \\\"--%s--\\\" % wrap_line(line)\\n assert wrap_line(line) == \\\"n\\\" * 79\",\n \"def insert_newline():\\r\\n insert_char(\\\"\\\\n\\\")\",\n \"def delimit(self):\\n pass\",\n \"def _justifyText(text):\\n chunks = text.split()\\n line = []\\n lineLength = 0\\n for chunk in chunks:\\n lineLength += len(chunk) + 1\\n if lineLength <= 73:\\n line.append(chunk)\\n continue\\n else:\\n print('''{:5}{:73}{}'''.format(\\\"|\\\", \\\" \\\".join(line), \\\"|\\\"))\\n del line[:]\\n line.append(chunk)\\n lineLength = len(chunk) + 1\\n print('''{:5}{:73}{}'''.format(\\\"|\\\", \\\" \\\".join(line), \\\"|\\\"))\",\n \"def left_justify_string(keyword, value):\\n return '%s' % keyword .ljust(40, \\\".\\\") + \\\": \\\" + '%s\\\\n' % value\",\n \"def add_spaces(text):\\n return \\\" \\\".join(text)\",\n \"def insert_key_padded(key: str) -> None:\\n around = actions.user.surrounding_text()\\n if not around or around.char_before != \\\" \\\":\\n insert(\\\" \\\")\\n try:\\n actions.key(key)\\n except ValueError:\\n # HACK: To insert \\\"keys\\\" like `->`\\n actions.insert(key)\\n if not around or around.char_after != \\\" \\\":\\n insert(\\\" \\\")\",\n \"def _addIndent(self, block, count=1):\\n return re.compile(r\\\"^((?!$))\\\", re.M).sub(\\\" \\\" * count, block)\",\n \"def pad_sentence_batch(sentence_batch):\\n max_sentence = max([len(sentence) for sentence in sentence_batch])\\n return [sentence + [CODES['<PAD>']] * (max_sentence - len(sentence))\\n for sentence in sentence_batch]\",\n \"def get_pad2(s1, s2):\\n return \\\" \\\" * (40 - len(s1) - len(s2))\",\n \"def get_pad(self, n):\\n pad = \\\"\\\"\\n for i in range(0, n):\\n pad += \\\" \\\"\\n return pad\",\n \"def _insert_leading_whitespace(self, line_list):\\n if self._leading_whitespace:\\n line_list[0] = '{0}{1}'.format(\\n self._leading_whitespace, line_list[0]\\n )\\n\\n return line_list\",\n \"def lf(self):\\n self._write('\\\\n')\",\n \"def _despace(statement):\\n return re.sub(r' +', ' ', statement)\",\n \"def cat(cls, sep):\\n return lambda x,y: (len(x)<10000) and \\\"%s%s%s\\\" % (x, sep, y) or x\",\n \"def adjustl(self):\\n s = self._val.lstrip()\\n pad_str = self.padding(len(s))\\n return s + pad_str\",\n \"def _filler(self, char, amount):\\n if not isinstance(char, ANSIString):\\n line = char * amount\\n return ANSIString(\\n char * amount,\\n code_indexes=[],\\n char_indexes=list(range(0, len(line))),\\n clean_string=char,\\n )\\n try:\\n start = char._code_indexes[0]\\n except IndexError:\\n start = None\\n end = char._char_indexes[0]\\n prefix = char._raw_string[start:end]\\n postfix = char._raw_string[end + 1 :]\\n line = char._clean_string * amount\\n code_indexes = [i for i in range(0, len(prefix))]\\n length = len(prefix) + len(line)\\n code_indexes.extend([i for i in range(length, length + len(postfix))])\\n char_indexes = self._shifter(list(range(0, len(line))), len(prefix))\\n raw_string = prefix + line + postfix\\n return ANSIString(\\n raw_string, clean_string=line, char_indexes=char_indexes, code_indexes=code_indexes\\n )\",\n \"def to_whitespace(self, empty=False, strip_nl=False, strip_comments=False):\\n if strip_nl and self.type == tokenize.NL:\\n self.string = \\\"\\\"\\n return\\n if strip_comments and self.type == tokenize.COMMENT:\\n self.string = \\\"\\\"\\n return\\n if self.type in ignored_types_set:\\n return\\n if empty:\\n self.string = \\\"\\\"\\n else:\\n self.string = \\\" \\\" * len(self.token_tuple[1])\",\n \"def space_delimited(cls, *columns: str) -> \\\"SpaceDelimitedTextPattern\\\":\\n return jsii.sinvoke(cls, \\\"spaceDelimited\\\", [*columns])\",\n \"def indent(text, first_line=True, n=1, width=4):\\n lines = text.split(\\\"\\\\n\\\")\\n if not first_line:\\n first = lines[0]\\n lines = lines[1:]\\n\\n spaces = \\\" \\\" * (width * n)\\n lines2 = [spaces + x for x in lines]\\n\\n if not first_line:\\n lines2.insert(0, first)\\n\\n indented = \\\"\\\\n\\\".join(lines2)\\n\\n return indented\",\n \"def r_pad(arg, length):\\n if length <= len(arg):\\n return arg\\n else:\\n return arg + \\\" \\\" * (length - len(arg))\",\n \"def test_blank_last_line():\\n column_1 = Column(\\\"Col 1\\\", width=10)\\n tc = TableCreator([column_1])\\n\\n row_data = ['my line\\\\n\\\\n']\\n row = tc.generate_row(row_data=row_data, is_header=False)\\n assert row == ('my line \\\\n'\\n ' ')\\n\\n row_data = ['\\\\n']\\n row = tc.generate_row(row_data=row_data, is_header=False)\\n assert row == ' '\\n\\n row_data = ['']\\n row = tc.generate_row(row_data=row_data, is_header=False)\\n assert row == ' '\",\n \"def add_line(self):\\n #N_spaces = message.count(' ') # From both sides\\n banner = 40\\n words = [self.your_string]\\n word_sum = sum(len(i) for i in words)\\n margin1 = int(banner/5)*\\\"=\\\"\\n margi1_len = len(margin1)\\n margin2 = (banner-(margi1_len+word_sum+2))*\\\"=\\\"\\n if len(margin1+self.your_string+margin2) < banner:\\n \\\"\\\"\\\"\\n Here for simple one line sentence we add\\n directly the margins with the self.your_string\\n \\\"\\\"\\\"\\n print(banner*\\\"=\\\")\\n print(f\\\"\\\"\\\"{margin1} {self.your_string} {margin2}\\\"\\\"\\\")\\n print(banner*\\\"=\\\")\\n else:\\n \\\"\\\"\\\"\\n Here we check the number of words and reset the list and\\n spaces everytime we go to a new line until the self.your_string\\n is finished.\\n \\\"\\\"\\\"\\n print(banner*\\\"=\\\")\\n wordsx = self.your_string.split()\\n xr = 4 # alignment added later (adjusted manually)\\n i = 0\\n spacex = 0\\n listwords = []\\n while i < len(wordsx):\\n\\n listwords.append(wordsx[i])\\n if sum(len(i) for i in listwords) + spacex < banner-xr:\\n print(wordsx[i], end = \\\" \\\")\\n spacex = spacex +1\\n\\n else:\\n print(wordsx[i])\\n listwords = []\\n spacex = 0\\n\\n i = i +1\\n\\n print(\\\"\\\\n\\\", end= \\\"\\\")\\n print(banner*\\\"=\\\")\",\n \"def pad(msg):\\n return msg + (BLOCK_SIZE - len(msg)) * PADDING\",\n \"def rehydrate_text(self, next_token):\\n prefix_text = \\\"\\\"\\n main_text = next_token.token_text.replace(\\n InlineHelper.backspace_character, \\\"\\\"\\n ).replace(\\\"\\\\x08\\\", \\\"\\\")\\n\\n print(\\n \\\">>rehydrate_text>>\\\" + main_text.replace(\\\"\\\\a\\\", \\\"\\\\\\\\a\\\").replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n )\\n main_text = self.resolve_replacement_markers(main_text)\\n print(\\n \\\"<<rehydrate_text>>\\\" + main_text.replace(\\\"\\\\a\\\", \\\"\\\\\\\\a\\\").replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n )\\n\\n print(\\n \\\"<<leading_whitespace>>\\\"\\n + next_token.extracted_whitespace.replace(\\\"\\\\a\\\", \\\"\\\\\\\\a\\\")\\n .replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n .replace(\\\"\\\\x03\\\", \\\"\\\\\\\\x03\\\")\\n )\\n leading_whitespace = self.resolve_replacement_markers(\\n next_token.extracted_whitespace\\n )\\n print(\\n \\\"<<leading_whitespace>>\\\"\\n + leading_whitespace.replace(\\\"\\\\a\\\", \\\"\\\\\\\\a\\\")\\n .replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n .replace(\\\"\\\\x03\\\", \\\"\\\\\\\\x03\\\")\\n )\\n if self.block_stack:\\n if (\\n self.block_stack[-1].token_name\\n == MarkdownToken.token_indented_code_block\\n ):\\n main_text = self.reconstitute_indented_text(\\n main_text,\\n self.block_stack[-1].extracted_whitespace,\\n self.block_stack[-1].indented_whitespace,\\n leading_whitespace,\\n )\\n prefix_text = \\\"\\\"\\n leading_whitespace = \\\"\\\"\\n elif self.block_stack[-1].token_name == MarkdownToken.token_html_block:\\n main_text += \\\"\\\\n\\\"\\n elif self.block_stack[-1].token_name == MarkdownToken.token_paragraph:\\n if \\\"\\\\n\\\" in main_text:\\n split_token_text = main_text.split(\\\"\\\\n\\\")\\n split_parent_whitespace_text = self.block_stack[\\n -1\\n ].extracted_whitespace.split(\\\"\\\\n\\\")\\n print(\\n \\\">>split_token_text>>\\\"\\n + str(split_token_text)\\n .replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n .replace(\\\"\\\\t\\\", \\\"\\\\\\\\t\\\")\\n )\\n print(\\n \\\">>split_parent_whitespace_text>>\\\"\\n + str(split_parent_whitespace_text)\\n .replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n .replace(\\\"\\\\t\\\", \\\"\\\\\\\\t\\\")\\n )\\n\\n # TODO never incrementing?\\n parent_rehydrate_index = self.block_stack[-1].rehydrate_index\\n\\n rejoined_token_text = []\\n for iterator in enumerate(split_token_text, start=0):\\n print(\\\">>\\\" + str(iterator))\\n if iterator[0] == 0:\\n joined_text = iterator[1]\\n else:\\n joined_text = (\\n split_parent_whitespace_text[\\n parent_rehydrate_index + iterator[0]\\n ]\\n + iterator[1]\\n )\\n rejoined_token_text.append(joined_text)\\n split_token_text = rejoined_token_text\\n\\n if next_token.end_whitespace:\\n split_end_whitespace_text = next_token.end_whitespace.split(\\n \\\"\\\\n\\\"\\n )\\n print(\\n \\\">>split_end_whitespace_text>>\\\"\\n + str(split_end_whitespace_text)\\n .replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n .replace(\\\"\\\\t\\\", \\\"\\\\\\\\t\\\")\\n )\\n assert len(split_token_text) == len(split_end_whitespace_text)\\n\\n joined_token_text = []\\n for iterator in enumerate(split_token_text):\\n print(\\\">>\\\" + str(iterator))\\n joined_text = (\\n iterator[1] + split_end_whitespace_text[iterator[0]]\\n )\\n joined_token_text.append(joined_text)\\n split_token_text = joined_token_text\\n main_text = \\\"\\\\n\\\".join(split_token_text)\\n elif self.block_stack[-1].token_name == MarkdownToken.token_setext_heading:\\n if \\\"\\\\n\\\" in main_text:\\n split_token_text = main_text.split(\\\"\\\\n\\\")\\n split_parent_whitespace_text = next_token.end_whitespace.split(\\\"\\\\n\\\")\\n print(\\n \\\">>split_token_text>>\\\"\\n + str(split_token_text)\\n .replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n .replace(\\\"\\\\t\\\", \\\"\\\\\\\\t\\\")\\n )\\n print(\\n \\\">>split_parent_whitespace_text>>\\\"\\n + str(split_parent_whitespace_text)\\n .replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n .replace(\\\"\\\\t\\\", \\\"\\\\\\\\t\\\")\\n )\\n\\n # TODO never incrementing?\\n parent_rehydrate_index = 0 # self.block_stack[-1].rehydrate_index\\n\\n rejoined_token_text = []\\n for iterator in enumerate(split_token_text, start=0):\\n print(\\\">>iterator=\\\" + str(iterator))\\n split_setext_text = []\\n ws_prefix_text = \\\"\\\"\\n ws_suffix_text = \\\"\\\"\\n if split_parent_whitespace_text[iterator[0]]:\\n split_setext_text = split_parent_whitespace_text[\\n iterator[0]\\n ].split(\\\"\\\\x02\\\")\\n print(\\\">>split_setext_text=\\\" + str(split_setext_text))\\n if len(split_setext_text) == 1:\\n if iterator[0] == 0:\\n ws_suffix_text = split_setext_text[0]\\n else:\\n ws_prefix_text = split_setext_text[0]\\n else:\\n assert len(split_setext_text) == 2\\n ws_prefix_text = split_setext_text[0]\\n ws_suffix_text = split_setext_text[1]\\n\\n joined_text = ws_prefix_text + iterator[1] + ws_suffix_text\\n rejoined_token_text.append(joined_text)\\n\\n print(\\\">>rejoined_token_text=\\\" + str(rejoined_token_text))\\n main_text = \\\"\\\\n\\\".join(rejoined_token_text)\\n return prefix_text + leading_whitespace + main_text\",\n \"def __split_seq(self, sequence):\\n seq = copy.copy(sequence)\\n result = \\\"\\\"\\n while len(seq) > self._max_len:\\n if seq[self._max_len] == \\\"\\\":\\n result += seq[:self._max_len] + \\\"\\\\n\\\"\\n seq = seq[self._max_len:]\\n else:\\n whitespace_index = self._max_len - seq[:self._max_len][::-1].find(\\\" \\\")\\n result += seq[:whitespace_index] + \\\"\\\\n\\\"\\n seq = seq[whitespace_index:]\\n result += seq\\n return result\",\n \"def rehydrate_paragraph_end(self, next_token):\\n assert next_token\\n top_stack_token = self.block_stack[-1]\\n del self.block_stack[-1]\\n return top_stack_token.final_whitespace + \\\"\\\\n\\\"\",\n \"def sep(s):\\n return ' '+s if s else s\",\n \"def wordwrap(value, arg=80):\\n\\treturn \\\"\\\\n\\\".join(textwrap.wrap(value, int(arg)))\",\n \"def get_orion_space_string(self) -> str:\",\n \"def line_blank(record):\\n record.colon = record.space = record.sep = record.levelname \\\\\\n = record.filename = record.lineno = record.threadName \\\\\\n = record.processName = ''\\n return record\",\n \"def space():\\n print(' ', end='')\",\n \"def padding(input_value, value):\\n padding_value = str(input_value)\\n for i in range(value - len(str(input_value))):\\n padding_value += \\\" \\\"\\n return padding_value\",\n \"def padding(self, n):\\n if n < self._length: # pad with blanks\\n k = self._length - n\\n pad_str = \\\" \\\" * k\\n else:\\n pad_str = \\\"\\\"\\n\\n return pad_str\",\n \"def _pad_sentence_length(self, sentence):\\n if len(sentence) > self.pad_sentence_length:\\n sentence = sentence[:self.pad_sentence_length]\\n sentence[self.pad_sentence_length-1] = \\\"@EOS@\\\"\\n elif len(sentence) < self.pad_sentence_length:\\n sentence.extend([\\\"@PAD@\\\"] * (self.pad_sentence_length - len(sentence)))\\n return sentence\",\n \"def Fill(self, line):\\n self._blank = True\\n for word in line.split():\\n if not self._fill:\\n self._fill = self._indent[self._level] - 1\\n self._out.write(' ' * self._fill)\\n n = self._attr.PrintWidth(word)\\n if self._fill + n + 1 >= self._width and not self._ignore_width:\\n self._out.write('\\\\n')\\n self._fill = self._indent[self._level]\\n self._out.write(' ' * self._fill)\\n else:\\n self._ignore_width = False\\n if self._fill:\\n self._fill += 1\\n self._out.write(' ')\\n self._fill += n\\n self._out.write(word)\",\n \"def indent(text, count=1, prefix=\\\" \\\"):\\n lines = text.split(\\\"\\\\n\\\")\\n return \\\"\\\\n\\\".join(\\\"{}{}\\\".format(prefix * count, line)\\n for line in lines)\",\n \"def finalize(self):\\n if self.whitespace:\\n return Token('', self.whitespace,\\n typ=Token.WHITESPACE, position=self.position)\\n return None\",\n \"def spacify(string):\\n return \\\" \\\" + \\\" \\\".join(string.splitlines(True))\",\n \"def insertNewlines(text, lineLength):\\r\\n lenCtr = 0\\r\\n this = []\\r\\n \\r\\n # convert entire text to a list of words\\r\\n words = text.split()\\r\\n \\r\\n # get a length of all the word\\r\\n for each in words[:]:\\r\\n lenCtr += len(each) + 1 # word length + whitespace\\r\\n this.append(each) # add word to this line\\r\\n words.remove(each) # remove word from remaining text\\r\\n print this,\\r\\n print words,\\r\\n print lenCtr\\r\\n if lenCtr >= lineLength:\\r\\n # insert \\\\n when lineLength is reached\\r\\n this.append('\\\\n')\\r\\n break\\r\\n # if itarable is exhausted, just return entire text\\r\\n else:\\r\\n return ' '.join(words)\\r\\n # remaining text\\r\\n text = ' '.join(words)\\r\\n return ' '.join(this) + insertNewlines(text, lineLength)\",\n \"def align_strings(strings, header=''):\\n spaces = [len(l)-len(l.lstrip()) for l in strings.data if l]\\n min_spaces = min(spaces) if spaces else 0\\n if min_spaces > 0 or header:\\n for index in range(len(strings.data)):\\n strings.data[index] = header + strings.data[index][min_spaces:]\",\n \"def _format_line(line: str, n: int, padding: int) -> str:\\n return ' {dim}{n}{reset}: {line}'.format(dim=Style.DIM,\\n n=str(n + 1).zfill(padding),\\n line=line,\\n reset=Style.RESET_ALL)\",\n \"def indent(value):\\n return \\\" \\\" + value\",\n \"def _pad_horizontally(self, chars_written):\\n if chars_written >= self.width:\\n return\\n\\n extra = self.width - chars_written\\n self.buf += ' ' * extra\",\n \"def __indent_text_block(text):\\n lines = text.splitlines()\\n if len(lines) > 1:\\n out = lines[0] + \\\"\\\\r\\\\n\\\"\\n for i in range(1, len(lines)-1):\\n out = out + \\\" \\\" + lines[i] + \\\"\\\\r\\\\n\\\"\\n out = out + \\\" \\\" + lines[-1]\\n return out\\n return text\",\n \"def pad_delimiters(string1, number, delimiter=',', slen=None, ):\\n current_num = string1.count(delimiter)\\n num_to_add = number - current_num\\n \\n curlen = len(string1)\\n \\n if num_to_add > 0:\\n if slen is not None:\\n len_to_add = slen - curlen\\n \\n spacing = int(len_to_add / num_to_add)\\n xtra = len_to_add % num_to_add\\n\\n s1 = (\\\"%\\\" + str(spacing) + \\\"s\\\") % delimiter\\n s1 = s1 * num_to_add + \\\" \\\" * xtra\\n string1 += s1\\n else:\\n string1 += delimiter * num_to_add\\n return string1\",\n \"def pad_chars(text, encoding=None, null_terminate=True, pad_to_multiple_of=4):\\n if pad_to_multiple_of < 0 or not isinstance(pad_to_multiple_of, int):\\n raise ValueError(\\\"pad must be an integer greater than zero.\\\")\\n if encoding is not None:\\n encoded = text.encode(encoding) + (b\\\"\\\\0\\\" if null_terminate else b\\\"\\\")\\n else:\\n encoded = text + (\\\"\\\\0\\\" if null_terminate else \\\"\\\")\\n pad = b\\\"\\\\0\\\" if encoding is not None else \\\"\\\\0\\\"\\n while len(encoded) % pad_to_multiple_of != 0:\\n encoded += pad\\n return encoded\",\n \"def feed(self, token, test_newline=True):\\n if test_newline:\\n newlines = token.count(self.newline_char)\\n if newlines:\\n self.line += newlines\\n self.line_start_pos = self.char_pos + token.rindex(self.newline_char) + 1\\n\\n self.char_pos += len(token)\\n self.column = self.char_pos - self.line_start_pos + 1\",\n \"def __Pad(self, data):\\n pad = self.block_size - len(data) % self.block_size\\n return data + pad * chr(pad)\",\n \"def fix_whitespace(lines: Sequence[str], eol: str, ends_with_eol: bool) -> str:\\n lines = _strip(lines)\\n lines = [i.expandtabs(4) for i in lines]\\n result = eol.join(lines)\\n if ends_with_eol:\\n result += eol\\n return result\",\n \"def _commandline_join(self, tokens):\\r\\n commands = filter(None, map(str, tokens))\\r\\n return self._command_delimiter.join(commands).strip()\",\n \"def _commandline_join(self, tokens):\\r\\n commands = filter(None, map(str, tokens))\\r\\n return self._command_delimiter.join(commands).strip()\",\n \"def _commandline_join(self, tokens):\\r\\n commands = filter(None, map(str, tokens))\\r\\n return self._command_delimiter.join(commands).strip()\",\n \"def _padboth(width, s):\\n fmt = \\\"{0:^%ds}\\\" % width\\n return fmt.format(s)\",\n \"def space(n):\\n rstr = \\\" \\\" * 4 * n\\n return rstr\",\n \"def pad_encoded_text(self, encoded_text):\\n\\n\\t\\textra_padding = 8 - len(encoded_text) % 8#calculmaos cuanto falta por agregar\\n\\t\\tfor i in range(extra_padding):\\n\\t\\t\\tencoded_text += \\\"0\\\"\\n\\n\\t\\tpadded_info = \\\"{0:08b}\\\".format(extra_padding)#le agregamos una informacion adicionar la cual utilizaremos despues al comprimir para saber cuantos 0 le agregamos y despues poder eliminarlos\\n\\t\\tencoded_text = padded_info + encoded_text\\n\\t\\treturn encoded_text\",\n \"def ljust(self, width, fillchar, _difference):\\n return self + self._filler(fillchar, _difference)\",\n \"def pad(text, width, pad_character=\\\" \\\"):\\n\\n length = len(text)\\n if width < 0 and length < -width:\\n return text + (-width - length) * pad_character\\n elif width > 0 and length < width:\\n return (width - length) * pad_character + text\\n else:\\n return text\",\n \"def __pad(self,buf):\\n return Utils.pad(buf,self.com.granularity)\",\n \"def hangingIndent(msg, numCols):\\r\\n\\tinsertPoint = numCols\\r\\n\\twhile insertPoint < len(msg):\\r\\n\\t\\tmsg = msg[:insertPoint] + \\\"\\\".center(INDENT_SIZE) + msg[insertPoint:]\\r\\n\\t\\tinsertPoint += numCols\\r\\n\\t\\r\\n\\treturn msg\",\n \"def _reset_leading_whitespace(self):\\n self._leading_whitespace = ''\",\n \"def get_indent(op):\\n ret = \\\"\\\"\\n for ii in range(op):\\n # Would tab be better?\\n ret += \\\" \\\"\\n return ret\",\n \"def fill(text,width=60):\\r\\n pars = [textwrap.fill(text,width) for text in text.split('\\\\n')]\\r\\n return '\\\\n'.join(pars)\",\n \"def dumb_formatter(out, text, left, right = None):\\n if right == None:\\n (right, line_length) = bigsh.pp.get_terminal_size()\\n if right - 20 > left: # XXX needs work\\n right = right - 20\\n right = min(right, 120)\\n\\n left_indent = ' ' * left\\n out_len = left\\n out_line = left_indent\\n\\n for line in text.split('\\\\n'):\\n if len(line) == 0:\\n if out_len > left:\\n out.append(out_line)\\n out_len = left\\n out_line = left_indent\\n out.append('')\\n elif line[0] == ' ' or line[0] == '\\\\t': # leading spaces\\n if out_len > left:\\n out.append(out_line)\\n out_len = left\\n out_line = left_indent\\n out.append( left_indent + line )\\n else: # text formatting\\n\\n for word in line.split():\\n sep = ' '\\n if word.endswith('.'):\\n sep = ' '\\n if len(word) + out_len + len(sep) > right:\\n if out_len > left:\\n out.append(out_line)\\n out_len = left + len(word) + len(sep)\\n out_line = left_indent + word + sep\\n else:\\n out_line += word + sep\\n out_len += len(sep) + len(word)\\n if out_len > left:\\n out.append(out_line)\",\n \"def pretty(self):\\n\\t\\tif not self.content.endswith('\\\\n'):\\n\\t\\t\\tself.content += '\\\\n'\",\n \"def pad(plain_text):\\n number_of_bytes_to_pad = block_size - len(plain_text) % block_size\\n ascii_string = chr(number_of_bytes_to_pad)\\n padding_str = number_of_bytes_to_pad * ascii_string\\n padded_plain_text = plain_text + padding_str\\n return padded_plain_text\",\n \"def newBuffer():\\n buffer = []\\n for i in range(0,8):\\n buffer.append(\\\" \\\")\\n return buffer\",\n \"def separeIndent(self,line):\\n p=0\\n while p<len(line) and line[p] in string.whitespace:\\n p=p+1\\n rest=line[p:]\\n return line[:p],rest\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6392049","0.6164877","0.60053855","0.5916133","0.5909493","0.5903229","0.57719034","0.5734293","0.57243377","0.56752753","0.5638436","0.5602468","0.5591528","0.55746096","0.5573323","0.55722106","0.55722106","0.55722106","0.5568011","0.549426","0.54902315","0.5473266","0.5472829","0.54649675","0.5463769","0.54507536","0.54499793","0.54466814","0.5443324","0.54358405","0.5432847","0.5424445","0.5412797","0.5403468","0.53960294","0.53955376","0.53944665","0.53894275","0.53789884","0.53655857","0.5362117","0.53500813","0.53478414","0.5339433","0.5336762","0.5331606","0.53118634","0.52885926","0.52780277","0.52494216","0.5239117","0.5237291","0.5226942","0.5226209","0.5224713","0.52149534","0.5204704","0.51997447","0.5187692","0.5183314","0.5177115","0.5174344","0.51725376","0.5171863","0.5169473","0.51679116","0.516718","0.5165466","0.51638323","0.5156161","0.5150231","0.5134666","0.51345116","0.51336354","0.5129621","0.51247376","0.5115718","0.51142263","0.5107375","0.5105736","0.5101067","0.51004505","0.5093207","0.5084649","0.5084649","0.5084649","0.50823104","0.50706774","0.5064703","0.50618815","0.50477916","0.504609","0.50456893","0.50345695","0.5034022","0.50270987","0.50248337","0.50130767","0.50111693","0.5002524","0.5000834"],"string":"[\n \"0.6392049\",\n \"0.6164877\",\n \"0.60053855\",\n \"0.5916133\",\n \"0.5909493\",\n \"0.5903229\",\n \"0.57719034\",\n \"0.5734293\",\n \"0.57243377\",\n \"0.56752753\",\n \"0.5638436\",\n \"0.5602468\",\n \"0.5591528\",\n \"0.55746096\",\n \"0.5573323\",\n \"0.55722106\",\n \"0.55722106\",\n \"0.55722106\",\n \"0.5568011\",\n \"0.549426\",\n \"0.54902315\",\n \"0.5473266\",\n \"0.5472829\",\n \"0.54649675\",\n \"0.5463769\",\n \"0.54507536\",\n \"0.54499793\",\n \"0.54466814\",\n \"0.5443324\",\n \"0.54358405\",\n \"0.5432847\",\n \"0.5424445\",\n \"0.5412797\",\n \"0.5403468\",\n \"0.53960294\",\n \"0.53955376\",\n \"0.53944665\",\n \"0.53894275\",\n \"0.53789884\",\n \"0.53655857\",\n \"0.5362117\",\n \"0.53500813\",\n \"0.53478414\",\n \"0.5339433\",\n \"0.5336762\",\n \"0.5331606\",\n \"0.53118634\",\n \"0.52885926\",\n \"0.52780277\",\n \"0.52494216\",\n \"0.5239117\",\n \"0.5237291\",\n \"0.5226942\",\n \"0.5226209\",\n \"0.5224713\",\n \"0.52149534\",\n \"0.5204704\",\n \"0.51997447\",\n \"0.5187692\",\n \"0.5183314\",\n \"0.5177115\",\n \"0.5174344\",\n \"0.51725376\",\n \"0.5171863\",\n \"0.5169473\",\n \"0.51679116\",\n \"0.516718\",\n \"0.5165466\",\n \"0.51638323\",\n \"0.5156161\",\n \"0.5150231\",\n \"0.5134666\",\n \"0.51345116\",\n \"0.51336354\",\n \"0.5129621\",\n \"0.51247376\",\n \"0.5115718\",\n \"0.51142263\",\n \"0.5107375\",\n \"0.5105736\",\n \"0.5101067\",\n \"0.51004505\",\n \"0.5093207\",\n \"0.5084649\",\n \"0.5084649\",\n \"0.5084649\",\n \"0.50823104\",\n \"0.50706774\",\n \"0.5064703\",\n \"0.50618815\",\n \"0.50477916\",\n \"0.504609\",\n \"0.50456893\",\n \"0.50345695\",\n \"0.5034022\",\n \"0.50270987\",\n \"0.50248337\",\n \"0.50130767\",\n \"0.50111693\",\n \"0.5002524\",\n \"0.5000834\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12895,"cells":{"query":{"kind":"string","value":"usalbe only when g_wc was used to find pr_wv"},"document":{"kind":"string","value":"def get_cnt_sw_list(g_sc, g_sa, g_wn, g_wc, g_wo, g_wvi,\r\n pr_sc, pr_sa, pr_wn, pr_wc, pr_wo, pr_wvi,\r\n g_sql_i, pr_sql_i,\r\n mode):\r\n cnt_sc = get_cnt_sc_list(g_sc, pr_sc)\r\n cnt_sa = get_cnt_sc_list(g_sa, pr_sa)\r\n cnt_wn = get_cnt_sc_list(g_wn, pr_wn)\r\n cnt_wc = get_cnt_wc_list(g_wc, pr_wc)\r\n cnt_wo = get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode)\r\n if pr_wvi:\r\n cnt_wvi = get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode)\r\n else:\r\n cnt_wvi = [0]*len(cnt_sc)\r\n cnt_wv = get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode) # compare using wv-str which presented in original data.\r\n\r\n\r\n return cnt_sc, cnt_sa, cnt_wn, cnt_wc, cnt_wo, cnt_wvi, cnt_wv"},"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_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode):\r\n cnt_list =[]\r\n for b, g_wc1 in enumerate(g_wc):\r\n pr_wn1 = len(pr_sql_i[b][\"conds\"])\r\n g_wn1 = g_wn[b]\r\n\r\n # Now sorting.\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx1 = argsort(array(g_wc1))\r\n elif mode == 'train':\r\n idx1 = list( range( g_wn1) )\r\n else:\r\n raise ValueError\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n flag = True\r\n for i_wn, idx11 in enumerate(idx1):\r\n g_wvi_str11 = str(g_sql_i[b][\"conds\"][idx11][2]).lower()\r\n pr_wvi_str11 = str(pr_sql_i[b][\"conds\"][i_wn][2]).lower()\r\n # print(g_wvi_str11)\r\n # print(pr_wvi_str11)\r\n # print(g_wvi_str11==pr_wvi_str11)\r\n if g_wvi_str11 != pr_wvi_str11:\r\n flag = False\r\n # print(g_wv1, g_wv11)\r\n # print(pr_wv1, pr_wv11)\r\n # input('')\r\n break\r\n if flag:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n\r\n return cnt_list","def _compute_wo(self):\n self.uom_id = self.wo_id.uom_id.id\n self.final_product_id = self.wo_id.final_product_id.id\n if not self.supplier_id:\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\n else:\n service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\n if service_ids:\n product_supp_rcs = self.env['product.supplierinfo'].search([('partner_id', '=', self.supplier_id.id), ('product_id', 'in', service_ids)])\n if product_supp_rcs:\n product_ids = [x.product_id.id for x in product_supp_rcs if x.product_id]\n else:\n product_ids = []\n else:\n product_ids = [] \n \n self.service_ids = product_ids\n \n # Permet de savoir si l'OT suivant est de sous-traitance et qu'il y a qu'un seul OT suivant\n no_direct_fp = True\n if self.wo_id.next_wo_ids and len(self.wo_id.next_wo_ids) == 1 and self.wo_id.next_wo_ids[0].is_subcontracting and self.wo_id.next_wo_ids[0].consumed_service_ids:\n no_direct_fp = False\n \n self.no_direct_fp = no_direct_fp","def convert_pr_wvi_to_string(pr_wvi, nlu_t, nlu_wp_t, wp_to_wh_index, nlu):\r\n pr_wv_str_wp = [] # word-piece version\r\n pr_wv_str = []\r\n for b, pr_wvi1 in enumerate(pr_wvi):\r\n pr_wv_str_wp1 = []\r\n pr_wv_str1 = []\r\n wp_to_wh_index1 = wp_to_wh_index[b]\r\n nlu_wp_t1 = nlu_wp_t[b]\r\n nlu_t1 = nlu_t[b]\r\n\r\n for i_wn, pr_wvi11 in enumerate(pr_wvi1):\r\n st_idx, ed_idx = pr_wvi11\r\n\r\n # Ad-hoc modification of ed_idx to deal with wp-tokenization effect.\r\n # e.g.) to convert \"butler cc (\" ->\"butler cc (ks)\" (dev set 1st question).\r\n pr_wv_str_wp11 = nlu_wp_t1[st_idx:ed_idx+1]\r\n pr_wv_str_wp1.append(pr_wv_str_wp11)\r\n\r\n st_wh_idx = wp_to_wh_index1[st_idx]\r\n ed_wh_idx = wp_to_wh_index1[ed_idx]\r\n pr_wv_str11 = nlu_t1[st_wh_idx:ed_wh_idx+1]\r\n\r\n pr_wv_str1.append(pr_wv_str11)\r\n\r\n pr_wv_str_wp.append(pr_wv_str_wp1)\r\n pr_wv_str.append(pr_wv_str1)\r\n\r\n return pr_wv_str, pr_wv_str_wp","def unknown(self, w):\n # WORK HERE!!","def _compute_wo(self):\n self.uom_id = self.wo_id.uom_id.id\n self.final_product_id = self.wo_id.final_product_id.id\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]","def get_wm_ws_Gx_bot(self):\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \n z_u_r = self.grid_dict['z_u_r']\n z_u_w = self.grid_dict['z_u_w']\n [Ly,N] = self.b.shape\n #---> j-loop\n for j in range(Ly): \n self.kbl[j] = N # initialize search\n #-> end j-loop\n\n #--> k-loop\n for k in range(N-1,0,-1):\n k_w = k\n k_r = k-1\n # --> j loop \n for j in range(Ly):\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\n self.kbl[j] = k_w\n\n #--> end k\n # --> end j\n\n\n '''\n Compute nondimenisonal shape function coefficeints Gx() by\n matching values and vertical derivatives of interior mixing\n coefficients at hbbl (sigma=1)\n '''\n\n self.Gm1_bot = np.zeros([Ly])\n self.dGm1_dS_bot = np.zeros([Ly])\n self.Gt1_bot = np.zeros([Ly])\n self.dGt1_dS_bot = np.zeros([Ly]) \n self.Av_bl_bot = np.zeros([Ly])\n self.dAv_bl_bot = np.zeros([Ly]) \n self.cff_up_bot = np.zeros([Ly])\n self.cff_dn_bot = np.zeros([Ly])\n\n\n\n\n\n self.wm_bot = np.zeros([Ly])\n self.ws_bot = np.zeros([Ly]) \n\n # CALCULATE ustar for the bottom based on bototm velocities\n \n \n \n # CALCULATE r_D\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \n u = self.u\n v_upts = TTTW_func.v2u(self.v)\n \n ubar = np.mean(u,axis=1)\n vbar = np.mean(v_upts,axis=1)\n\n # --> j loop\n for j in range(Ly):\n # turbulent velocity sclaes with buoyancy effects neglected\n if self.CD_SWITCH:\n # DEPTH AVERAGED APPROACH\n uref = u[j,0]\n vref = v_upts[j,0]\n ustar2 = self.C_D * (uref**2 + vref**2)\n else:\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\n wm = self.vonKar * np.sqrt(ustar2)\n ws = wm\n\n self.wm_bot[j] = wm\n self.ws_bot[j] = ws\n \n k_w = self.kbl[j] \n z_bl = z_u_w[j,0] + self.hbbl[j]\n\n if z_bl < z_u_w[j,k_w-1]:\n k_w = k_w-1\n\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl_bot[j] = Av_bl\n self.dAv_bl_bot[j] = dAv_bl\n\n\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\n\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])","def grounding_words(self, w):\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])","def wisdom(search_me, source, pdfurl, userid):\n ### source needs to be name of data source (\"arxiv\", \"google scholar\", \"doaj\")\n search_me = search_me.strip()\n # check if pdfurl has been found before\n pdf = db_summaries.find_one({\"url\": pdfurl})\n if pdf:\n text = pdf.get('text')\n summary = pdf.get('summary')\n topics = pdf.get('topics')\n # update in db if data is 1 days or older\n last_updated = datetime.utcnow() - pdf.get(\"last_updated\")\n last_updated_diff = last_updated.days\n if last_updated_diff > 1:\n search_term = db_search_terms.find_one({\"value\": search_me.lower()})\n search_id = search_term.get(\"_id\")\n data = {\"search_id\": search_id,\n \"url\": pdfurl, \"source\": source, \"text\": text,\n \"summary\": summary, \"topics\": topics, \"last_updated\": datetime.utcnow()}\n db_summaries.update({\"url\": pdfurl}, {\"$set\": data})\n else:\n pass\n else:\n text = wisdomaiengine.pdfdocumentextracter(pdfurl)\n summary = wisdomaiengine.summarisepdfdocument(text)\n topics = wisdomaiengine.wordcloud(search_me, text)\n if topics is None:\n topics = ['No Topics Found']\n # write data to arxiv collection\n search_term = db_search_terms.find_one({\"value\": search_me.lower()})\n search_id = search_term.get(\"_id\")\n data = {\"search_id\": search_id,\n \"url\": pdfurl,\n \"source\": source,\n \"text\": text,\n \"summary\": summary,\n \"topics\": topics,\n \"last_updated\": datetime.utcnow()}\n x = db_summaries.insert(data, check_keys=False)\n # return json\n summaryjson = jsonify(wisdomtopics=topics, wisdomsummary=summary)\n return summaryjson","def get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode):\r\n cnt_list =[]\r\n for b, g_wvi1 in enumerate(g_wvi):\r\n g_wc1 = g_wc[b]\r\n pr_wvi1 = pr_wvi[b]\r\n pr_wn1 = len(pr_wvi1)\r\n g_wn1 = g_wn[b]\r\n\r\n # Now sorting.\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx1 = argsort(array(g_wc1))\r\n elif mode == 'train':\r\n idx1 = list( range( g_wn1) )\r\n else:\r\n raise ValueError\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n flag = True\r\n for i_wn, idx11 in enumerate(idx1):\r\n g_wvi11 = g_wvi1[idx11]\r\n pr_wvi11 = pr_wvi1[i_wn]\r\n if g_wvi11 != pr_wvi11:\r\n flag = False\r\n # print(g_wv1, g_wv11)\r\n # print(pr_wv1, pr_wv11)\r\n # input('')\r\n break\r\n if flag:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n\r\n return cnt_list","def get_wotd():\n\treturn wotd","def _get_wred(self):\n return self.__wred","def _get_wred(self):\n return self.__wred","def _get_wred(self):\n return self.__wred","def get_warc(self):\n raise NotImplementedError()","def svn_info_t_has_wc_info_get(svn_info_t_self): # real signature unknown; restored from __doc__\n pass","def wing(self):\n return","def is_wcw(status):\n test_text = ' '.join(status['text'].lower().split()) # Remove capital letters and excessive whitespace/linebreaks\n usernames = ['just_to_say_bot', 'thisisjustbot', 'Dcd200S', 'willslostplum', 'sosweetbot', 'JustToSayBot', 'thatisjustplums', \\\n\t\t 'EatenBot', 'the_niche_bot', 'KristenCostel10', 'litabottal', 'pythonnina', 'alatest5', 'LisaRob96585017','Stilson28400122', \\\n\t\t 'JohnDun40217560','Cordelia28', 'Rick63556459', 'botsnthings', 'timbot301', 'Rachel53001595', 'NicholasMillma6', 'ThisIsJustTo1'\\\n\t\t'MayISay4', 'breakfast_plum', 'BotBot53368932'] # Block screen_names of known parody accounts\n if status['user']['screen_name'] not in usernames and all(u not in status['text'] for u in usernames) and 'Cheap Bots, Done Quick!' not in status['source']:\n if 'which you were probably' in test_text: # Capture parodies of the form\n return True\n elif 'plums' in test_text and 'icebox' in test_text: # Capture parodies of the content\n return True\n elif 'plum' in test_text and 'icebox' in test_text: # Capture singular 'plum'\n return True\n elif 'plums' in test_text and 'ice box' in test_text: #Capture 'ice box' with a space\n return True\n elif 'plum' in test_text and 'ice box' in test_text: \n return True\n elif 'William Carlos Williams'.lower() in test_text and 'plums' in test_text: #Capture mentions of WCW\n return True\n elif 'William Carlos Williams'.lower() in test_text and 'plum' in test_text:\n return True\n elif 'this is just to say' in test_text and 'that were in' in test_text: # Get only relevant instances of \"this is just to say\"\n return True\n elif 'this is just to say' in test_text and 'forgive me' in test_text:\n return True\n elif 'this is just to say' in test_text and 'and so' in test_text:\n return True\n elif 'so sweet and so cold' in test_text and 'the arms of the ocean' not in test_text: # Get 'so sweet and so cold' tweets that aren't quoting Florence and the Machine\n return True\n else:\n return False\n else:\n return False","def get_WS(w2v):\n # get set of MAX_NGRAM-grams in text\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 ngrams_in_data = set()\n for words in raw:\n for ngram in tweet_to_ngrams(words):\n ngrams_in_data.add(ngram)\n\n # load sentiment features from model\n clf_pipe = pickle.load(open(CLF_FNAME, 'rb')) # model\n\n vect = clf_pipe.best_estimator_.named_steps['vect']\n clf = clf_pipe.best_estimator_.named_steps['clf']\n\n features_to_sent_idx = vect.vocabulary_ # map from model features to sentiment index\n # currently, sentiment = 2 * (count_pos / (count_pos + count_neg)) - 1\n sentiments = clf.feature_count_[1,:] / np.sum(clf.feature_count_, axis=0) # in [0,1]\n sentiments = 2 * sentiments - 1 # rescale to [-1,1]\n\n features_to_sent = {feat: sentiments[idx] for (feat,idx) in features_to_sent_idx.items()}\n\n # build WS and ngram_idx_map for each MAX_NGRAM-gram in the text\n k = len(next(iter(w2v.values()))) # dimension of embedding\n WS = np.zeros(shape=(len(ngrams_in_data) + 1, k + MAX_NGRAM), dtype='float32')\n ngram_idx_map = {}\n\n index = 1 # first row is left 0, for padding in the cnn. This is also neutral sentiment.\n # For Vader Sentiment analysis\n# vader_analyzer = SentimentIntensityAnalyzer()\n\n\n for ngram in ngrams_in_data:\n ngram_idx_map[ngram] = index\n\n # set word embedding, note that unknown words already randomized in load_embedding \n words = ngram.split(' ')\n WS[index,:k] = w2v[words[-1]] # embedding of last word\n\n # set sentiment embedding\n for n in range(MAX_NGRAM): # for 1, 2, ... length ngrams\n sub_ngram = ' '.join(words[-1 - n:]) \n\n # Naive Bayes Sentiment feature --------------------------------\n sent = features_to_sent.get(sub_ngram, 0.0) # default to neutral 0\n # --------------------------------------------------------------\n\n# # TextBlob sentiment feature -----------------------------------\n# sent = TextBlob(sub_ngram).sentiment.polarity\n# # --------------------------------------------------------------\n\n# # Vader sentiment feature -------------------------------------\n# sent = vader_analyzer.polarity_scores(sub_ngram)['compound']\n# # -------------------------------------------------------------\n WS[index,k+n] = sent\n\n index += 1\n\n return WS, ngram_idx_map","def combined_wcs(self) -> BaseHighLevelWCS:","def handlehtmlsearch_wok(querystring, keywordstring, searchlimit, cache, smartconstrain):\n mpsearch, keywords, constraints = handlehtmlsearch_mp(querystring, keywordstring, cache, smartconstrain)\n\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'rt') as record:\n try:\n wlist = json.load(record)\n except ValueError:\n wlist = {}\n\n searchtotal = 0\n for search in mpsearch:\n searchtotal += len(search)\n\n wokresults = []\n i = 0\n\n for search in mpsearch:\n for n in search:\n iterinput = []\n for m in n['unit_cell_formula'].keys():\n iterinput.append(m + str(int(n['unit_cell_formula'][m])))\n\n iterlist = list(itertools.permutations(iterinput))\n\n searchparam = 'topic:' + n['pretty_formula'] + ' or topic:' + n['full_formula']\n\n for term in iterlist:\n searchparam += ' or topic:' + ''.join(term)\n\n i += 1\n if n['material_id'] in wlist.keys() and cache:\n print('loading wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\n wokresults.append(wlist[n['material_id']])\n else:\n print('searching wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\n try:\n searchdata = searchWoKTools.getsearchdata(searchparam, searchlimit)\n except:\n with open('wokRecord.json', 'wt') as record:\n json.dump(wlist, record)\n raise\n\n searchdata[0].update(n)\n wlist[n['material_id']] = searchdata\n wokresults.append(searchdata)\n\n mpsearch, wokresults = searchWoKTools.removeconstrainedwok(mpsearch, wokresults, constraints)\n\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'wt') as record:\n json.dump(wlist, record)\n\n keyresults = []\n for search in wokresults:\n keyresults.append(searchWoKTools.getkeylist(search, keywords))\n\n return keywords, mpsearch, wokresults, keyresults","def pwgrwlfilter(self):\n return None","def treat_page(self):\n # let's define some basic variables\n urtext = self.current_page.text\n urlang = self.current_page.site.code\n urtitle = self.current_page.title()\n urcat = []\n eng_site = pywikibot.Site('en')\n eng_title = ''\n \n interDict = {}\n try:\n site = pywikibot.Site('ur', 'wikipedia')\n urpage = pywikibot.Page(site, urtitle)\n langlst = urpage.iterlanglinks()\n\n \n for i in langlst:\n lang = str(i.site).split(':')[1]\n interDict[lang] = i.title\n \n eng_title = interDict['en']\n except:\n pywikibot.output(u'\\03{lightred}Unable to fetch interwiki links!\\03{default}')\n return False\n \n site = pywikibot.Site('en', 'wikipedia')\n enpage = pywikibot.Page(site, eng_title)\n\n wikitext = enpage.get() \n wikicode = mwp.parse(wikitext)\n\n # Extracting sfn templates and converting them in REF tags\n sfnlist = []\n for template in wikicode.filter_templates():\n if template.name in ('sfn', 'sfn'):\n sfnlist.append(template)\n templ_rep = '<ref>' + str(template) + '</ref>'\n wikicode.replace(template , templ_rep)\n\n alltags = wikicode.filter_tags() \n reftags = {}\n \n def search(myDict, search1):\n for key, value in myDict.items():\n if search1 in value: \n return key \n \n i=1\n for tag in alltags:\n if tag.tag=='ref':\n if tag.attributes == []: # check if attributes list is empty\n refval='NoRefName' # Reference has no name so assigning \"NoRefName\"\n else:\n name = tag.attributes[0]\n refval = name.value\n \n if tag.contents is None:\n #conval = search(reftags,refval)\n #reftags[i] = (refval,reftags[conval][1])\n pass\n else: \n reftags[i] = (refval,tag.contents)\n i += 1\n\n dlinks = {}\n for k,v in reftags.items():\n dkey = 'و' + str(k) + 'و'\n dlinks[dkey] = '<ref>' + str(v[1]) + '</ref>'\n\n urtext = urpage.text\n for r in tuple(dlinks.items()):\n urtext = urtext.replace(*r)\n\n # newln = '\\n'\n # Using noreferences to add Reference template if not present\n self.norefbot = noreferences.NoReferencesBot(None)\n if self.norefbot.lacksReferences(urtext):\n urtext = self.norefbot.addReferences(urtext)\n else:\n urpage.text = urtext + '\\n'\n\n print(urpage.text)\n \n # save the page \n urpage.save(summary=self.summary, minor=False)\n #self.put_current(urpage.text, summary=self.summary)","def CC_wdw(self):\n # Setup param\n loc = 'TSdata'\n if 'single' == self.newParam['survey_type']:\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc).shape[0]\n elif 'multiple' == self.newParam['survey_type']:\n TS_group = dt.utilities.DB_group_names(self.Database, group_name = loc)[0]\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc+'/'+TS_group).shape[0]\n\n param = self.newParam\n\n # Assign TS processing length to end_wdws if given\n if param['end_wdws']:\n TS_sig_len = param['end_wdws']\n else:\n TS_sig_len = TS_len\n\n ERROR_MESSAGE = 'The length of a TS signal to be processed is', TS_sig_len, \\\n 'which is < end of the last window'\n\n # Calculate wdwPos for overlapping windows of ww_ol if wdwPos is False\n if param['wdwPos'][0] is False:\n # Error checks\n if TS_sig_len < self.newParam['ww'][0]:\n raise Warning(ERROR_MESSAGE)\n\n wdwStep = np.floor(param['ww'][0] *\n (100 - param['ww_ol']) / 100)\n\n if self.verbose: print('* Length fo TSdata', TS_len)\n\n max_wdwPos = TS_sig_len - param['ww'][0] + 1\n wdwStarts = np.arange(0 + param['sta_wdws'], max_wdwPos, wdwStep).astype(int)\n\n if self.verbose: print('* The step in window potions is %s sample points' % wdwStep)\n if self.verbose: print('* The max window postions is %s sample points'% max_wdwPos)\n\n param['wdwPos'] = [ [wdw_start, wdw_start + param['ww'][0]] for\n wdw_start in wdwStarts ]\n\n # Only update wdwPos structure if not already done so\n elif np.array(param['wdwPos'][0]).shape == ():\n param['wdwPos'] = [ [wdw_start, wdw_start + ww] for wdw_start,ww in\n zip(param['wdwPos'], param['ww'])]\n\n self.newParam['wdwPos'] = param['wdwPos']","def fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw):\n\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\n\tTocwf=Vk*Ck*Dk/GDen\n\treturn Tocwf","def buildWPriorTerm(self):\r\n\r\n # self.w_prior.shape == (minibatch size,)\r\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\r\n\r\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)","def wkt(self): # -> str:\n ...","def _new_wos_dict():\n wos_dict = {\n 'DI': None,\n 'TI': None,\n 'PY': None,\n 'SO': None,\n 'UT': None,\n 'DE': None,\n }\n\n return wos_dict","def wing_geom_eval(self, cpacs):\n\n log.info(\"---------- Analysing wing geometry ----------\")\n\n # Opening tixi and tigl\n tixi = cpacs.tixi\n tigl = cpacs.tigl\n\n # Counting wing number without symmetry --------------------------------------\n w_nb = tixi.getNamedChildrenCount(WINGS_XPATH, \"wing\")\n\n # INITIALIZATION 1 -----------------------------------------------------------\n self.w_nb = w_nb\n self.wing_nb = w_nb\n wing_plt_area_xz = []\n wing_plt_area_yz = []\n wingUID = []\n\n # Counting sections and segments----------------------------------------------\n b = 0\n for i in range(1, w_nb + 1):\n double = 1\n self.wing_sym.append(tigl.wingGetSymmetry(i))\n if self.wing_sym[i - 1] != 0:\n double = 2 # To consider the real amount of wing\n # when they are defined using symmetry\n self.wing_nb += 1\n self.wing_sec_nb.append(tigl.wingGetSectionCount(i))\n self.wing_seg_nb.append(tigl.wingGetSegmentCount(i))\n self.wing_vol.append(tigl.wingGetVolume(i) * double)\n\n self.wing_plt_area.append(tigl.wingGetReferenceArea(i, 1) * double) # x-y plane\n wing_plt_area_xz.append(tigl.wingGetReferenceArea(i, 2) * double) # x-z plane\n wing_plt_area_yz.append(tigl.wingGetReferenceArea(i, 3) * double) # y-z plane\n\n self.wing_tot_vol = self.wing_tot_vol + self.wing_vol[i - 1]\n wingUID.append(tigl.wingGetUID(i))\n self.wing_span.append(tigl.wingGetSpan(wingUID[i - 1]))\n a = np.amax(self.wing_span)\n # Evaluating the index that corresponds to the main wing\n if a > b:\n self.main_wing_index = i\n b = a\n\n # Checking segment and section connection and reordering them\n (\n self.wing_sec_nb,\n _,\n seg_sec,\n _,\n ) = self.wing_check_segment_connection(wing_plt_area_xz, wing_plt_area_yz, tigl)\n\n # INITIALIZATION 2 -----------------------------------------------------------\n\n max_wing_sec_nb = np.amax(self.wing_sec_nb)\n max_wing_seg_nb = np.amax(self.wing_seg_nb)\n wing_center_section_point = np.zeros((max_wing_sec_nb, w_nb, 3))\n self.wing_center_seg_point = np.zeros((max_wing_seg_nb, self.wing_nb, 3))\n self.wing_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\n self.wing_fuel_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\n self.wing_fuel_vol = 0\n self.wing_mac = np.zeros((4, w_nb))\n self.wing_sec_thickness = np.zeros((max_wing_sec_nb + 1, w_nb))\n\n # WING ANALYSIS --------------------------------------------------------------\n\n # Main wing plantform area\n self.wing_plt_area_main = self.wing_plt_area[self.main_wing_index - 1]\n\n # Wing: MAC,chords,thickness,span,plantform area ------------------------------\n\n for i in range(1, w_nb + 1):\n mac = tigl.wingGetMAC(wingUID[i - 1])\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, 1, 0.0, 0.0)\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, 1, 0.0, 1.0)\n self.wing_max_chord.append(\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\n )\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 0.0)\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 1.0)\n self.wing_min_chord.append(\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\n )\n for k in range(1, 5):\n self.wing_mac[k - 1][i - 1] = mac[k - 1]\n for jj in range(1, self.wing_seg_nb[i - 1] + 1):\n j = int(seg_sec[jj - 1, i - 1, 2])\n cle = tigl.wingGetChordPoint(i, j, 0.0, 0.0)\n self.wing_seg_vol[j - 1][i - 1] = tigl.wingGetSegmentVolume(i, j)\n lp = tigl.wingGetLowerPoint(i, j, 0.0, 0.0)\n up = tigl.wingGetUpperPoint(i, j, 0.0, 0.0)\n if np.all(cle == lp):\n L = 0.25\n else:\n L = 0.75\n if np.all(cle == up):\n U = 0.25\n else:\n U = 0.75\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, j, 0.0, L)\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, j, 0.0, U)\n wing_center_section_point[j - 1][i - 1][0] = (wplx + wpux) / 2\n wing_center_section_point[j - 1][i - 1][1] = (wply + wpuy) / 2\n wing_center_section_point[j - 1][i - 1][2] = (wplz + wpuz) / 2\n self.wing_sec_thickness[j - 1][i - 1] = np.sqrt(\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\n )\n j = int(seg_sec[self.wing_seg_nb[i - 1] - 1, i - 1, 2])\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, self.wing_seg_nb[i - 1], 1.0, L)\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, self.wing_seg_nb[i - 1], 1.0, U)\n self.wing_sec_thickness[j][i - 1] = np.sqrt(\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\n )\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][0] = (wplx + wpux) / 2\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][1] = (wply + wpuy) / 2\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][2] = (wplz + wpuz) / 2\n self.wing_sec_mean_thick.append(\n np.mean(self.wing_sec_thickness[0 : self.wing_seg_nb[i - 1] + 1, i - 1])\n )\n # Evaluating wing fuel tank volume in the main wings\n if abs(round(self.wing_plt_area[i - 1], 3) - self.wing_plt_area_main) < 0.001:\n tp_ratio = self.wing_min_chord[i - 1] / self.wing_max_chord[i - 1]\n ratio = round(tp_ratio * self.wing_plt_area[i - 1] / 100, 1)\n if ratio >= 1.0:\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.8, 2)\n elif ratio >= 0.5:\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.72, 2)\n else:\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.5, 2)\n for j in seg_sec[:, i - 1, 2]:\n if j == 0.0:\n break\n self.wing_fuel_seg_vol[int(j) - 1][i - 1] = round(\n (self.wing_seg_vol[int(j) - 1][i - 1] / (sum(self.wing_vol)))\n * self.wing_fuel_vol,\n 2,\n )\n if (\n self.wing_plt_area[i - 1] > wing_plt_area_xz[i - 1]\n and self.wing_plt_area[i - 1] > wing_plt_area_yz[i - 1]\n ):\n self.is_horiz.append(True)\n if self.wing_sym[i - 1] != 0:\n self.is_horiz.append(True)\n else:\n self.is_horiz.append(False)\n if self.wing_sym[i - 1] != 0:\n self.is_horiz.append(False)\n\n # Wing segment length evaluating function\n self.get_wing_segment_length(wing_center_section_point)\n\n # Evaluating the point at the center of each segment, the center\n # is placed at 1/4 of the chord, symmetry is considered.\n\n a = 0\n c = False\n for i in range(1, int(self.wing_nb) + 1):\n if c:\n c = False\n continue\n for jj in range(1, self.wing_seg_nb[i - a - 1] + 1):\n j = int(seg_sec[jj - 1, i - a - 1, 2])\n self.wing_center_seg_point[j - 1][i - 1][0] = (\n wing_center_section_point[j - 1][i - a - 1][0]\n + wing_center_section_point[j][i - a - 1][0]\n ) / 2\n self.wing_center_seg_point[j - 1][i - 1][1] = (\n wing_center_section_point[j - 1][i - a - 1][1]\n + wing_center_section_point[j][i - a - 1][1]\n ) / 2\n self.wing_center_seg_point[j - 1][i - 1][2] = (\n wing_center_section_point[j - 1][i - a - 1][2]\n + wing_center_section_point[j][i - a - 1][2]\n ) / 2\n if self.wing_sym[i - 1 - a] != 0:\n if self.wing_sym[i - 1 - a] == 1:\n symy = 1\n symx = 1\n symz = -1\n if self.wing_sym[i - 1 - a] == 2:\n symy = -1\n symx = 1\n symz = 1\n if self.wing_sym[i - 1 - a] == 3:\n symy = 1\n symx = -1\n symz = 1\n self.wing_center_seg_point[:, i, 0] = (\n self.wing_center_seg_point[:, i - 1, 0] * symx\n )\n self.wing_center_seg_point[:, i, 1] = (\n self.wing_center_seg_point[:, i - 1, 1] * symy\n )\n self.wing_center_seg_point[:, i, 2] = (\n self.wing_center_seg_point[:, i - 1, 2] * symz\n )\n c = True\n a += 1\n\n self.w_seg_sec = seg_sec\n\n self.wing_area = round(self.wing_plt_area_main, 3)\n\n log.info(\"---------------------------------------------\")\n log.info(\"--------------- Wing Results ----------------\")\n log.info(f\"Number of Wings [-]: {self.wing_nb}\")\n log.info(f\"Wing symmetry plane [-]: {self.wing_sym}\")\n log.info(f\"Number of wing sections (not counting symmetry) [-]: {self.wing_sec_nb}\")\n log.info(f\"Number of wing segments (not counting symmetry) [-]: {self.wing_seg_nb}\")\n log.info(f\"Wing Span [m]: {self.wing_span}\")\n log.info(f\"Wing MAC length [m]: {self.wing_mac[0,]}\")\n log.info(f\"Wing max chord length [m]: {self.wing_max_chord}\")\n log.info(f\"Wing min chord length [m]: {self.wing_min_chord}\")\n log.info(f\"Main wing plantform area [m^2]: {self.wing_plt_area_main}\")\n log.info(f\"Wings plantform area [m^2]: {self.wing_plt_area}\")\n log.info(f\"Volume of each wing [m^3]: {self.wing_vol}\")\n log.info(f\"Total wing volume [m^3]: {self.wing_tot_vol}\")\n log.info(f\"Wing volume for fuel storage [m^3]: {self.wing_fuel_vol}\")\n log.info(\"---------------------------------------------\")","def get_wo_mthly_smry(self, workorder_browse):\n wo_summary_data = []\n wo_check_dict = {}\n no = 0\n if workorder_browse:\n for work_rec in workorder_browse:\n if work_rec.state and work_rec.state == \"done\":\n no += 1\n identification = \"\"\n repair_line_data = \"\"\n if work_rec.vehicle_id:\n identification += work_rec.vehicle_id.name\n if work_rec.vehicle_id.f_brand_id:\n identification += \" \" + work_rec.vehicle_id.f_brand_id.name\n if work_rec.vehicle_id.model_id:\n identification += \" \" + work_rec.vehicle_id.model_id.name\n for repaire_line in work_rec.repair_line_ids:\n if repaire_line.complete is True:\n if (\n repaire_line.repair_type_id\n and repaire_line.repair_type_id.name\n ):\n repair_line_data += (\n repaire_line.repair_type_id.name + \", \"\n )\n if work_rec.parts_ids:\n for parts_line in work_rec.parts_ids:\n if work_rec.id in wo_check_dict.keys():\n parts_data = {\n \"no\": -1,\n \"location\": \"\",\n \"type\": \"\",\n \"wo\": \"\",\n \"identification\": \"\",\n \"vin\": \"\",\n \"plate_no\": \"\",\n \"work_performed\": \"\",\n \"part\": parts_line.product_id\n and parts_line.product_id.default_code\n or \"\",\n \"qty\": parts_line.qty or 0.0,\n \"uom\": parts_line.product_uom\n and parts_line.product_uom.name\n or \"\",\n }\n wo_summary_data.append(parts_data)\n else:\n wo_check_dict[work_rec.id] = work_rec.id\n parts_data = {\n \"no\": no,\n \"location\": work_rec.team_id\n and work_rec.team_id.name\n or \"\",\n \"type\": work_rec.main_type or \"\",\n \"wo\": work_rec.name or \"\",\n \"identification\": identification or \"\",\n \"vin\": work_rec.vehicle_id\n and work_rec.vehicle_id.vin_sn\n or \"\",\n \"plate_no\": work_rec.vehicle_id\n and work_rec.vehicle_id.license_plate\n or \"\",\n \"work_performed\": repair_line_data\n and repair_line_data[:-2]\n or \"\",\n \"part\": parts_line.product_id\n and parts_line.product_id.default_code\n or \"\",\n \"qty\": parts_line.qty or 0.0,\n \"uom\": parts_line.product_uom\n and parts_line.product_uom.name\n or \"\",\n }\n wo_summary_data.append(parts_data)\n else:\n parts_data = {\n \"no\": no,\n \"location\": work_rec.team_id\n and work_rec.team_id.name\n or \"\",\n \"type\": work_rec.main_type or \"\",\n \"wo\": work_rec.name or \"\",\n \"identification\": identification or \"\",\n \"vin\": work_rec.vehicle_id\n and work_rec.vehicle_id.vin_sn\n or \"\",\n \"plate_no\": work_rec.vehicle_id\n and work_rec.vehicle_id.license_plate\n or \"\",\n \"work_performed\": repair_line_data\n and repair_line_data[:-2]\n or \"\",\n \"vehicle_make\": \"\",\n \"qty\": \"\",\n \"uom\": \"\",\n }\n wo_summary_data.append(parts_data)\n if not wo_summary_data:\n msg = _(\n \"Warning! \\n\\\n No data Available for selected work order.\"\n )\n raise UserError(msg)\n return wo_summary_data","def analyzeWeights(self, occludedPortions):\r\n\t\treturn None","def update(self):\n self.wc.update()","def original_wcs(self):\n return self._owcs","def lookup(doc, wv):\n checked = []\n for word in doc:\n try:\n word in wv\n except KeyError:\n log.warning(\"Word not in model: %s\", word)\n continue\n checked.append(wv[word])\n vec = np.mean(checked, axis=0)\n return vec","def give_wv_units(wave):\n if not hasattr(wave, 'unit'):\n uwave = u.Quantity(wave, unit=u.AA)\n elif wave.unit is None:\n uwave = u.Quantity(wave, unit=u.AA)\n else:\n uwave = u.Quantity(wave)\n\n return uwave","def get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode):\r\n cnt_list=[]\r\n for b, g_wo1 in enumerate(g_wo):\r\n g_wc1 = g_wc[b]\r\n pr_wc1 = pr_wc[b]\r\n pr_wo1 = pr_wo[b]\r\n pr_wn1 = len(pr_wo1)\r\n g_wn1 = g_wn[b]\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx = argsort(array(g_wc1))\r\n\r\n g_wo1_s = array(g_wo1)[idx]\r\n g_wo1_s = list(g_wo1_s)\r\n elif mode == 'train':\r\n # due to tearch forcing, no need to sort.\r\n g_wo1_s = g_wo1\r\n else:\r\n raise ValueError\r\n\r\n if type(pr_wo1) != list:\r\n raise TypeError\r\n if g_wo1_s == pr_wo1:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n return cnt_list","def wrez2xml(self,newdoc,newroot):\n\t\twrez = newdoc.createElement('wrez')\n\t\twrez.setAttribute('hasChanged', str(self.hasChanged))\n\t\tnewroot.appendChild(wrez)\n\n\t\tpath = newdoc.createElement('path')\n\t\tpath.setAttribute('value', self.path)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('init_str')\n\t\tpath.setAttribute('value', self.init_str)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('hash_sha512')\n\t\tpath.setAttribute('value', self.hash_sha512)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('src_rip')\n\t\tpath.setAttribute('value', self.src_rip)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('quality')\n\t\tpath.setAttribute('value', self.quality)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('codec')\n\t\tpath.setAttribute('value', self.codec)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('language')\n\t\tpath.setAttribute('value', self.language)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('audio')\n\t\tpath.setAttribute('value', self.audio)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('encoder')\n\t\tpath.setAttribute('value', self.encoder)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('version')\n\t\tpath.setAttribute('value', self.version)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('extension')\n\t\tpath.setAttribute('value', self.extension)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('release_year')\n\t\tpath.setAttribute('value', self.release_year)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('title')\n\t\tpath.setAttribute('value', self.title)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('size')\n\t\tpath.setAttribute('value', str(self.size))\n\t\twrez.appendChild(path)\n\t\treturn wrez","def test_mlpi_cwro(self):\r\n\t\twith open(\"test_mlpi_cwro.txt\", \"w\") as test_mlpi_cwro_output:\r\n\t\t\tsys.stdout = test_mlpi_cwro_output\r\n\t\t\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=100, censor_words_one_pass=True)\r\n\t\twith open(\"test_mlpi_cwro.txt\", \"r\") as test_mlpi_cwro_output:\r\n\t\t\twhile True:\r\n\t\t\t\tline_output = test_mlpi_cwro_output.readline()\r\n\t\t\t\tline_correct = cc_test_prose.readline()\r\n\t\t\t\tself.assertEqual(line_output, line_correct)\r\n\t\t\t\tif line_correct == '':\r\n\t\t\t\t\tbreak\r\n\t\tcc_test_prose.seek(0)\r\n\t\tsys.stdout = sys.__stdout__\r\n\t\tos.remove(\"test_mlpi_cwro.txt\")","def onReload(self, event):\n\n\t\tself.wv.Reload()","def primalrepair(self,wlc,wuc,wlx,wux): # 3\n if wlc is None:\n wlc_ = None\n else:\n try:\n wlc_ = memoryview(wlc)\n except TypeError:\n try:\n _tmparr_wlc = array.array(\"d\",wlc)\n except TypeError:\n raise TypeError(\"Argument wlc has wrong type\")\n else:\n wlc_ = memoryview(_tmparr_wlc)\n \n else:\n if wlc_.format != \"d\":\n wlc_ = memoryview(array.array(\"d\",wlc))\n \n if wlc_ is not None and len(wlc_) != self.getnumcon():\n raise ValueError(\"Array argument wlc has wrong length\")\n if wuc is None:\n wuc_ = None\n else:\n try:\n wuc_ = memoryview(wuc)\n except TypeError:\n try:\n _tmparr_wuc = array.array(\"d\",wuc)\n except TypeError:\n raise TypeError(\"Argument wuc has wrong type\")\n else:\n wuc_ = memoryview(_tmparr_wuc)\n \n else:\n if wuc_.format != \"d\":\n wuc_ = memoryview(array.array(\"d\",wuc))\n \n if wuc_ is not None and len(wuc_) != self.getnumcon():\n raise ValueError(\"Array argument wuc has wrong length\")\n if wlx is None:\n wlx_ = None\n else:\n try:\n wlx_ = memoryview(wlx)\n except TypeError:\n try:\n _tmparr_wlx = array.array(\"d\",wlx)\n except TypeError:\n raise TypeError(\"Argument wlx has wrong type\")\n else:\n wlx_ = memoryview(_tmparr_wlx)\n \n else:\n if wlx_.format != \"d\":\n wlx_ = memoryview(array.array(\"d\",wlx))\n \n if wlx_ is not None and len(wlx_) != self.getnumvar():\n raise ValueError(\"Array argument wlx has wrong length\")\n if wux is None:\n wux_ = None\n else:\n try:\n wux_ = memoryview(wux)\n except TypeError:\n try:\n _tmparr_wux = array.array(\"d\",wux)\n except TypeError:\n raise TypeError(\"Argument wux has wrong type\")\n else:\n wux_ = memoryview(_tmparr_wux)\n \n else:\n if wux_.format != \"d\":\n wux_ = memoryview(array.array(\"d\",wux))\n \n if wux_ is not None and len(wux_) != self.getnumvar():\n raise ValueError(\"Array argument wux has wrong length\")\n res = self.__obj.primalrepair(wlc_,wuc_,wlx_,wux_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def primalrepair(self,wlc_,wuc_,wlx_,wux_):\n _wlc_minlength = self.getnumcon()\n if self.getnumcon() > 0 and wlc_ is not None and len(wlc_) != self.getnumcon():\n raise ValueError(\"Array argument wlc is not long enough: Is %d, expected %d\" % (len(wlc_),self.getnumcon()))\n if isinstance(wlc_, numpy.ndarray) and wlc_.dtype is numpy.dtype(numpy.float64) and wlc_.flags.contiguous:\n _wlc_copyarray = False\n _wlc_tmp = ctypes.cast(wlc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wlc_ is not None:\n _wlc_copyarray = True\n _wlc_np_tmp = numpy.zeros(len(wlc_),numpy.dtype(numpy.float64))\n _wlc_np_tmp[:] = wlc_\n assert _wlc_np_tmp.flags.contiguous\n _wlc_tmp = ctypes.cast(_wlc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wlc_copyarray = False\n _wlc_tmp = None\n \n _wuc_minlength = self.getnumcon()\n if self.getnumcon() > 0 and wuc_ is not None and len(wuc_) != self.getnumcon():\n raise ValueError(\"Array argument wuc is not long enough: Is %d, expected %d\" % (len(wuc_),self.getnumcon()))\n if isinstance(wuc_, numpy.ndarray) and wuc_.dtype is numpy.dtype(numpy.float64) and wuc_.flags.contiguous:\n _wuc_copyarray = False\n _wuc_tmp = ctypes.cast(wuc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wuc_ is not None:\n _wuc_copyarray = True\n _wuc_np_tmp = numpy.zeros(len(wuc_),numpy.dtype(numpy.float64))\n _wuc_np_tmp[:] = wuc_\n assert _wuc_np_tmp.flags.contiguous\n _wuc_tmp = ctypes.cast(_wuc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wuc_copyarray = False\n _wuc_tmp = None\n \n _wlx_minlength = self.getnumvar()\n if self.getnumvar() > 0 and wlx_ is not None and len(wlx_) != self.getnumvar():\n raise ValueError(\"Array argument wlx is not long enough: Is %d, expected %d\" % (len(wlx_),self.getnumvar()))\n if isinstance(wlx_, numpy.ndarray) and wlx_.dtype is numpy.dtype(numpy.float64) and wlx_.flags.contiguous:\n _wlx_copyarray = False\n _wlx_tmp = ctypes.cast(wlx_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wlx_ is not None:\n _wlx_copyarray = True\n _wlx_np_tmp = numpy.zeros(len(wlx_),numpy.dtype(numpy.float64))\n _wlx_np_tmp[:] = wlx_\n assert _wlx_np_tmp.flags.contiguous\n _wlx_tmp = ctypes.cast(_wlx_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wlx_copyarray = False\n _wlx_tmp = None\n \n _wux_minlength = self.getnumvar()\n if self.getnumvar() > 0 and wux_ is not None and len(wux_) != self.getnumvar():\n raise ValueError(\"Array argument wux is not long enough: Is %d, expected %d\" % (len(wux_),self.getnumvar()))\n if isinstance(wux_, numpy.ndarray) and wux_.dtype is numpy.dtype(numpy.float64) and wux_.flags.contiguous:\n _wux_copyarray = False\n _wux_tmp = ctypes.cast(wux_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wux_ is not None:\n _wux_copyarray = True\n _wux_np_tmp = numpy.zeros(len(wux_),numpy.dtype(numpy.float64))\n _wux_np_tmp[:] = wux_\n assert _wux_np_tmp.flags.contiguous\n _wux_tmp = ctypes.cast(_wux_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wux_copyarray = False\n _wux_tmp = None\n \n res = __library__.MSK_XX_primalrepair(self.__nativep,_wlc_tmp,_wuc_tmp,_wlx_tmp,_wux_tmp)\n if res != 0:\n _,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def vp():\r\n section = document.add_section()\r\n new_width, new_height = section.page_height, section.page_width\r\n section.orientation = WD_ORIENT.LANDSCAPE\r\n section.page_width = 10058400\r\n section.page_height = 7772400\r\n document.add_heading('Virtual Proxy details', 1)\r\n virtualproxy_metrics= ['description', 'prefix', 'authenticationModuleRedirectUri', 'sessionModuleBaseUri', 'loadBalancingModuleBaseUri', 'authenticationMethod', 'headerAuthenticationMode',\r\n 'headerAuthenticationHeaderName', 'headerAuthenticationStaticUserDirectory', 'headerAuthenticationDynamicUserDirectory', 'anonymousAccessMode', 'windowsAuthenticationEnabledDevicePattern',\r\n 'sessionCookieHeaderName', 'sessionCookieDomain', 'additionalResponseHeaders', 'sessionInactivityTimeout', 'extendedSecurityEnvironment', 'websocketCrossOriginWhiteList', 'defaultVirtualProxy',\r\n 'tags','samlMetadataIdP', 'samlHostUri', 'samlEntityId', 'samlAttributeUserId', 'samlAttributeUserDirectory', 'samlAttributeSigningAlgorithm', 'samlAttributeMap', 'magicLinkHostUri',\r\n 'magicLinkFriendlyName','jwtPublicKeyCertificate','jwtAttributeUserDirectory','jwtAttributeMap','jwtAttributeUserId']\r\n \r\n virtualproxynodes = get_qlik_sense.get_virtualproxy()\r\n num_of_virtualproxys = len(virtualproxynodes)\r\n num_of_virtualproxy_metrics = len(virtualproxy_metrics)\r\n table = document.add_table(rows=num_of_virtualproxy_metrics+1, cols=num_of_virtualproxys+1)\r\n table.style = 'Grid Table 1 Light Accent 1'\r\n row = table.rows[0]\r\n row.cells[0].text = 'Metric'\r\n for item in range(0, num_of_virtualproxys):\r\n row.cells[item+1].text = virtualproxynodes[item][29]\r\n for item in range(num_of_virtualproxy_metrics):\r\n row = table.rows[item+1]\r\n row.cells[0].text = str(virtualproxy_metrics[item])\r\n for virtualproxynode in range(num_of_virtualproxys):\r\n row.cells[virtualproxynode+1].text = str(virtualproxynodes[virtualproxynode][item])\r\n\r\n document.add_page_break()","def get_bforce_wm_ws_Gx_surf(self):\n\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w'] \n \n self.Gm1 = np.zeros([Ly])\n self.dGm1_dS = np.zeros([Ly]) \n self.Gt1 = np.zeros([Ly])\n self.dGt1_dS = np.zeros([Ly]) \n self.Bfsfc_bl = np.zeros([Ly])\n self.Av_bl = np.zeros([Ly])\n self.dAv_bl = np.zeros([Ly])\n \n #debugging\n self.wm_surf = np.zeros([Ly])\n self.ws_surf = np.zeros([Ly]) \n\n #---> j-loop\n for j in range(Ly): \n k_w = self.kbl[j] # KBL is \"new bl index after calling find_new_kbl()\n z_bl = z_u_w[j,N] - self.hbls[j]\n zscale = self.hbls[j] \n \n if self.swr_frac[j,k_w-1] > 0:\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\n \n else:\n Bfsfc = self.Bo[j] + self.Bosol[j]\n \n # CALCUALTE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm_surf[j] = wm\n self.ws_surf[j] = ws \n\n if self.LIMIT_UNSTABLE_ONLY:\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\n else:\n f1 = 0\n\n \n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n\n #MOMENTUM \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl[j] = Av_bl\n self.dAv_bl[j] = dAv_bl\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \n\n #TEMPERATURE(BUOYANCY)\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \n\n self.Bfsfc_bl[j] = Bfsfc","def get_w(self):\n raise NotImplementedError","def propose(self):\n\n\n fb = 0.0\n changed_any = False\n\n while not changed_any:\n new = copy(self) ## Now we just copy the whole thing\n\n for w in self.all_words():\n if flip(self.propose_p):\n try:\n xp, xfb = self.get_word(w).propose()\n\n changed_any = True\n new.set_word(w, xp)\n fb += xfb\n\n except ProposalFailedException:\n pass\n\n\n return new, fb","def build_W(points):\n return None","def computeW(self):\n E = np.where(self.v > 0, 1, -1)\n # theshold the connections to only -1,1\n binary_weights = np.where(self.c > 0, 1, self.c)\n binary_weights = np.where(binary_weights < 0, -1, binary_weights)\n W = np.sum(binary_weights * np.dot(E.reshape(-1,1), E.reshape(1,-1))) # W = C * E * E\n self.W = W\n if np.sum(binary_weights) != 0:\n self.W = self.W / np.sum(binary_weights) # W / W*\n return self.W","def vcac_worklfow_request(self):\n logging.info(\"Inside ucsvm_worklfow_request method base class\")\n return None","def get_wordcloud():\n params = request.args\n result = None\n\n def set_result(x):\n nonlocal result # This is ugly, ew, gotta fix this\n result = x\n\n pipeline_zoo.get_full_word_distribution(set_result).feed_data((params, None))\n return jsonify({\n 'word_distribution': result\n })","def get_vector(word, model):\n return model.wv[word]","def new_words_only(base_words, window_words):\n new_words = []\n if base_words:\n for wword in window_words:\n dont_include = False\n for bword in base_words:\n if CharNetRunner._do_words_intersect(wword, bword):\n dont_include = True\n break\n if not dont_include:\n new_words.append(wword)\n else:\n new_words = window_words\n\n return new_words","def search_clues(self):\r\n print(\"\\n************Searching Clues************\\n\")\r\n for word_id in self.words.keys():\r\n if not self.words[word_id].see and not self.words[word_id].wth:\r\n clue = pop_backslash(self.words[word_id].clue)\r\n temp = word_domain(\"allintext:\" + clue +' -crossword',self.words[word_id].length)\r\n temp2 = temp + word_domain(clue +' -crossword',self.words[word_id].length)\r\n domain = temp2 + data_muse(clue, self.words[word_id].length)\r\n unique_list = []\r\n for x in domain: \r\n y = x.upper()\r\n # check if exists in unique_list or not \r\n if y not in unique_list: \r\n unique_list.append(y) \r\n \r\n self.words[word_id].assign_word_domain(unique_list)\r\n print(\"\\nSearch is done...\")","def build_parameters(pobj):\n ViscosityWilke.build_parameters(pobj)","def wps(model, data):\n with msg.loading(f\"Loading model '{model}'...\"):\n nlp = spacy.load(model)\n texts = (eg[\"text\"] for eg in srsly.read_jsonl(data))\n n_docs = 0\n n_words = 0\n start_time = timer()\n for doc in nlp.pipe(texts):\n n_docs += 1\n n_words += len(doc)\n end_time = timer()\n wps = int(n_words / (end_time - start_time))\n result = [\n (\"Docs\", f\"{n_docs:,}\"),\n (\"Words\", f\"{n_words:,}\"),\n (\"Words/s\", f\"{wps:,}\"),\n ]\n msg.table(result, widths=(7, 12), aligns=(\"l\", \"r\"))","def isMWS_WD(primary=None, gaia=None, galb=None, astrometricexcessnoise=None,\n pmra=None, pmdec=None, parallax=None, parallaxovererror=None,\n photbprpexcessfactor=None, astrometricsigma5dmax=None,\n gaiagmag=None, gaiabmag=None, gaiarmag=None, paramssolved=None):\n if primary is None:\n primary = np.ones_like(gaia, dtype='?')\n mws = primary.copy()\n\n # ADM do not target any objects for which entries are NaN\n # ADM and turn off the NaNs for those entries.\n if photbprpexcessfactor is not None:\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\n np.isnan(parallax) | np.isnan(photbprpexcessfactor))\n else:\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\n np.isnan(parallax))\n w = np.where(nans)[0]\n if len(w) > 0:\n parallax, gaiagmag = parallax.copy(), gaiagmag.copy()\n gaiabmag, gaiarmag = gaiabmag.copy(), gaiarmag.copy()\n if photbprpexcessfactor is not None:\n photbprpexcessfactor = photbprpexcessfactor.copy()\n # ADM safe to make these zero regardless of cuts as...\n photbprpexcessfactor[w] = 0.\n parallax[w] = 0.\n gaiagmag[w], gaiabmag[w], gaiarmag[w] = 0., 0., 0.\n # ADM ...we'll turn off all bits here.\n mws &= ~nans\n# log.info('{}/{} NaNs in file...t = {:.1f}s'\n# .format(len(w), len(mws), time()-start))\n\n # ADM apply the selection for all MWS-WD targets\n # ADM must be a Legacy Surveys object that matches a Gaia source\n mws &= gaia\n\n # ADM and all astrometric parameters are measured.\n mws &= paramssolved == 31\n\n # ADM Gaia G mag of less than 20\n mws &= gaiagmag < 20.\n\n # ADM Galactic b at least 20o from the plane\n mws &= np.abs(galb) > 20.\n\n # ADM gentle cut on parallax significance\n mws &= parallaxovererror > 1.\n\n # ADM Color/absolute magnitude cuts of (defining the WD cooling sequence):\n # ADM Gabs > 5\n # ADM Gabs > 5.93 + 5.047(Bp-Rp)\n # ADM Gabs > 6(Bp-Rp)3 - 21.77(Bp-Rp)2 + 27.91(Bp-Rp) + 0.897\n # ADM Bp-Rp < 1.7\n Gabs = gaiagmag+5.*np.log10(parallax.clip(1e-16))-10.\n br = gaiabmag - gaiarmag\n mws &= Gabs > 5.\n mws &= Gabs > 5.93 + 5.047*br\n mws &= Gabs > 6*br*br*br - 21.77*br*br + 27.91*br + 0.897\n mws &= br < 1.7\n\n # ADM Finite proper motion to reject quasars\n # ADM Inexplicably I'm getting a Runtimewarning here for\n # ADM a few values in the sqrt, so I'm catching it\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n pm = np.sqrt(pmra**2. + pmdec**2.)\n mws &= pm > 2.\n\n # ADM As of DR7, photbprpexcessfactor and astrometricsigma5dmax are not in the\n # ADM imaging catalogs. Until they are, ignore these cuts\n if photbprpexcessfactor is not None:\n # ADM remove problem objects, which often have bad astrometry\n mws &= photbprpexcessfactor < 1.7 + 0.06*br*br\n\n if astrometricsigma5dmax is not None:\n # ADM Reject white dwarfs that have really poor astrometry while\n # ADM retaining white dwarfs that only have relatively poor astrometry\n mws &= ((astrometricsigma5dmax < 1.5) |\n ((astrometricexcessnoise < 1.) & (parallaxovererror > 4.) & (pm > 10.)))\n\n return mws","def get_doc_prov(j, gcis_url, refList):\n gcis_ns = \"https://gcis-search-stage.jpl.net:3000/gcis.owl#\"\n doc = ProvEsDocument()\n bndl = None\n \n#to get people attributed to, you need to grab article -> jornal_identifier -> look up in references\n# for ref in refList:\n# if ref['child_publication'] == j['uri']:\n \n\n\n doc_attrs = [\n (\"prov:type\", 'gcis:Article'),\n (\"prov:label\", j['title']),\n (\"prov:location\", j['uri']),\n #(\"prov:wasAttributedTo\", j['']),\n ]\n doc.entity('bibo:%s' % j['identifier'], doc_attrs)\n\n prov_json = json.loads(doc.serialize())\n\n return prov_json","def test_visualize_wfe_budget():\n nrc = webbpsf.NIRCam()\n nrc.visualize_wfe_budget()","def evaluate_design(self): # to update the pr object","def getVWFile(tsvFile, vwFile, dataIndex, dictionary, tfidf_model, train=True):\r\n start = datetime.now()\r\n \r\n # extract all the index\r\n catIndex = dataIndex[\"catIndex\"]\r\n subCatIndex = dataIndex[\"subCatIndex\"]\r\n attrsKeyIndex = dataIndex[\"attrsKeyIndex\"]\r\n attrsValIndex = dataIndex[\"attrsValIndex\"]\r\n wordIndex = dataIndex[\"wordIndex\"]\r\n \r\n with open(vwFile, \"wb\") as vwWriter:\r\n with open(tsvFile, \"rb\") as tsvReader:\r\n itemReader = DictReader(tsvReader, delimiter='\\t', quotechar='\"')\r\n for i, item in enumerate(itemReader):\r\n item = {featureName:featureValue.decode('utf-8') \\\r\n for featureName,featureValue in item.items() \\\r\n if featureValue is not None}\r\n\r\n # get header\r\n itemid = int(item[\"itemid\"])\r\n label = int(item[\"is_blocked\"]) if train else 1\r\n header = \"%s '%s \" % (int(2*label - 1), itemid)\r\n \r\n # category\r\n categoryFeat = \"|C %s \" % catIndex[ item[\"category\"] ]\r\n \r\n # subcategory\r\n subcategoryFeat = \"|SC %s \" % subCatIndex[ item[\"subcategory\"] ]\r\n \r\n # title\r\n title = [ str(wordIndex[w]) for w in getWords(item[\"title\"]) ]\r\n # first-gram\r\n title_start = title[0] if len(title)>0 else \"0\"\r\n # end-gram\r\n title_end = title[-1] if len(title)>0 else \"0\"\r\n # naming is a pain for me\r\n titleFeat = \"|T %s |bT %s |cT %s \" % (\" \".join(title), title_start, title_end)\r\n titleStatsFeat = \"|t %s \" % getTextStatsFeat(item[\"title\"])\r\n \r\n # description\r\n description = [ str(wordIndex[w]) for w in getWords(item[\"description\"]) ]\r\n # first-gram\r\n description_start = description[0] if len(description)>0 else \"0\"\r\n # end-gram\r\n description_end = description[-1] if len(description)>0 else \"0\"\r\n descriptionFeat = \"|D %s |fD %s |gD %s \" % (\" \".join(description), description_start, description_end)\r\n descriptionStatsFeat = \"|d %s \" % getTextStatsFeat(item[\"description\"])\r\n tfidf_feat1 = getTfidfFeat(getUnigram(description), dictionary[1], tfidf_model[1])\r\n # 2gram tfidf seem to harm the performance, you are save to drop it here\r\n tfidf_feat2 = getTfidfFeat(getBigram(description, \"_\"), dictionary[2], tfidf_model[2])\r\n descriptionFeat += \"|iD %s |jD %s \" % (tfidf_feat1, tfidf_feat2)\r\n \r\n # attrs\r\n attrsFeat = \"\"\r\n countAttrs = 0\r\n if \"attrs\" in item:\r\n attrsDict = getAttrsDict(item[\"attrs\"])\r\n #print attrs\r\n for k,v in list(attrsDict.items()):\r\n countAttrs += 1\r\n attrsFeat += \"|A%s %s \" % (attrsKeyIndex[k], attrsValIndex[v])\r\n attrsFeat += \"|a \"\r\n for k,v in list(attrsDict.items()):\r\n attrsFeat += \"%s \" % (attrsKeyIndex[k]) \r\n if len(attrsFeat) == 0:\r\n attrsFeat = \"|NA 1 \"\r\n attrsFeat += \"|hAC %s \" % countAttrs\r\n \r\n # price\r\n priceFeat = \"|P %s \" % item[\"price\"] \r\n # phones_cnt\r\n phonesCntFeat = \"|p %s \" % item[\"phones_cnt\"]\r\n # emails_cnt\r\n emailsCntFeat = \"|e %s \" % item[\"emails_cnt\"]\r\n # urls_cnt\r\n urlsCntFeat = \"|u %s \" % item[\"urls_cnt\"]\r\n \r\n # output\r\n vwLine = header \\\r\n + categoryFeat \\\r\n + subcategoryFeat \\\r\n + titleFeat \\\r\n + titleStatsFeat \\\r\n + descriptionFeat \\\r\n + descriptionStatsFeat \\\r\n + attrsFeat \\\r\n + priceFeat \\\r\n + phonesCntFeat \\\r\n + emailsCntFeat \\\r\n + urlsCntFeat[:-1] + \"\\n\"\r\n vwWriter.write( vwLine )\r\n \r\n # report progress\r\n if (i+1)%10000 == 0:\r\n print(( \"\\n%s\\t%s\"%((i+1),str(datetime.now() - start)) ))\r\n print(( \"Sample output:\\n%s\" % vwLine ))","def check_wf(self,wf):\n pass","def geocube():","def has_wcs(self):\n return self.wcs is not None","def plotrgcloud(self):\n print self.kpunten\n for i in range(len(self.kpunten[0])):\n self.writetext('sen ='+ self.kpunten[0][i][0], (0.65,0.85), axnum = 0, hor = None ,ver = None , rot = None ,fs =14 , transform = self.fig.axes[0].transAxes)\n if i == len(self.kpunten[0]) -1 :\n end = None\n else:\n end = self.kpunten[0][i+1][1] + 1\n print end\n self.plotrgwrap( self.rgindex,2*self.reader.npair+self.rgindex,'real part of rgvars (a.u)' , 'imaginary part of rgvars (a.u.)', tit ='RG vars g = %f all states'%(self.chardata) , begin = self.kpunten[0][i][1] , stop = end , name = 'cpcloud'+ self.kpunten[0][i][0] , filenum = 0)","def newWS(self, y):\n keys=np.array(self.ImageSolution.keys())\n try:\n i=abs(keys-y).argmin()\n ws=self.ImageSolution[keys[i]]\n nws=WavelengthSolution.WavelengthSolution(ws.x_arr,ws.w_arr, order=ws.order, function=ws.function)\n nws.fit()\n return nws\n except :\n return self.ws","def calc_wvf(pedestrian, key, face, mesh_area,radius): \n normal = envuo.py3dmodel.construct.make_vector((0,0,0),envuo.py3dmodel.calculate.face_normal(face))\n surf2ped = envuo.py3dmodel.construct.make_vector(key,pedestrian)\n sa_ped = 4.0*np.pi*radius**2\n theta = normal.Angle(surf2ped)\n h = surf2ped.Magnitude()/radius \n phi = np.arctan(1/h)\n threshold = np.pi/2.0 - phi\n\n if abs(h*np.cos(theta)) > 1:\n F = abs(np.cos(theta))/h**2; \n else:\n x = np.sqrt(h**2-1)/np.tan(theta) #np.sqrt(h**2-1)\n y = np.sqrt(1-x**2) #-x/np.tan(theta) #\n F = (np.pi - abs(np.cos(x)) - x*y*np.tan(theta)**2)*abs(np.cos(theta))/(np.pi*h**2) + np.arctan(y*abs(np.cos(theta))/x)/np.pi; \n print pedestrian,' passes threshold'\n return mesh_area*F/sa_ped","def compute_RS(W):\n return None","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',\n verbose=False))\n # No NaNs are supposed to be in the output.\n self.assertEqual(np.isnan(wv).any(), False)\n rms1 = rms(rec['wv_250_500_25'], wv[250:500:25])\n rms2 = rms(rec['wv_750_1000_25'], wv[750:1000:25])\n self.assertEqual(True, rms1 < 1e-6)\n self.assertEqual(True, rms2 < 1e-6)","def test_slpi_cwro(self):\r\n\t\twith open(\"test_slpi_cwro.txt\", \"w\") as test_slpi_cwro_output:\r\n\t\t\tsys.stdout = test_slpi_cwro_output # Redirect print in censor to temporary output file\r\n\t\t\t# Appropriate censor function call\r\n\t\t\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=1, censor_words_one_pass=True)\r\n\t\twith open(\"test_slpi_cwro.txt\", \"r\") as test_slpi_cwro_output:\r\n\t\t\twhile True:\r\n\t\t\t\t# Assert every output line in file matches the expected output\r\n\t\t\t\tline_output = test_slpi_cwro_output.readline()\r\n\t\t\t\tline_correct = cc_test_prose.readline()\r\n\t\t\t\tself.assertEqual(line_output, line_correct)\r\n\t\t\t\tif line_correct == '': # Stop reading expected output at eof\r\n\t\t\t\t\tbreak\r\n\t\tcc_test_prose.seek(0) # Reset read head in expected output file\r\n\t\tsys.stdout = sys.__stdout__ # Reset stdout redirection\r\n\t\tos.remove(\"test_slpi_cwro.txt\") # Delete temporary output file if test is successful\r","def _vSWVT(self):\r\n\r\n logStr = \"{0:s}.{1:s}: \".format(self.__class__.__name__, sys._getframe().f_code.co_name)\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'Start.')) \r\n \r\n try: \r\n vSWVT = None\r\n vSWVT=pd.merge(self.dataFrames['SWVT'],self.dataFrames['SWVT_ROWT'],left_on='pk',right_on='fk')\r\n vSWVT['ZEIT']=pd.to_numeric(vSWVT['ZEIT']) \r\n vSWVT['W']=pd.to_numeric(vSWVT['W']) \r\n vSWVT['ZEIT_RANG']=vSWVT.groupby(['pk_x'])['ZEIT'].rank(ascending=True)\r\n #\r\n vSWVT_g=vSWVT.groupby(['pk_x'], as_index=False).agg({'W':[np.min,np.max]})\r\n vSWVT_g.columns= [tup[0]+tup[1] for tup in zip(vSWVT_g.columns.get_level_values(0),vSWVT_g.columns.get_level_values(1))]\r\n vSWVT_g.rename(columns={'Wamin':'W_min','Wamax':'W_max'},inplace=True)\r\n #\r\n vSWVT=pd.merge(vSWVT,vSWVT_g,left_on='pk_x',right_on='pk_x')\r\n #\r\n vSWVT=vSWVT[vSWVT['ZEIT_RANG']==1]\r\n #\r\n vSWVT=vSWVT[['NAME','BESCHREIBUNG','INTPOL','ZEITOPTION','W','W_min','W_max','pk_x']]\r\n #\r\n vSWVT.rename(columns={'pk_x':'pk'},inplace=True)\r\n \r\n except Exception as e:\r\n logStrFinal=\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\r\n logger.error(logStrFinal) \r\n raise XmError(logStrFinal) \r\n finally:\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'_Done.'))\r\n return vSWVT","def collecte_docs(self, chercheur, overwrite=False): # self,\n init = overwrite # If True, data persistence is lost when references are updated\n docs = hal.find_publications(chercheur[\"halId_s\"], \"authIdHal_s\")\n\n progress_recorder = ProgressRecorder(self)\n progress_recorder.set_progress(0, len(docs), description=\"récupération des données HAL\")\n # Insert documents collection\n for num, doc in enumerate(docs):\n doc[\"country_colaboration\"] = location_docs.generate_countrys_fields(doc)\n doc = doi_enrichissement.docs_enrichissement_doi(doc)\n if \"fr_abstract_s\" in doc.keys():\n if isinstance(doc[\"fr_abstract_s\"], list):\n doc[\"fr_abstract_s\"] = \"/n\".join(doc[\"fr_abstract_s\"])\n if len(doc[\"fr_abstract_s\"]) > 100:\n doc[\"fr_entites\"] = keyword_enrichissement.return_entities(\n doc[\"fr_abstract_s\"], \"fr\"\n )\n doc[\"fr_teeft_keywords\"] = keyword_enrichissement.keyword_from_teeft(\n doc[\"fr_abstract_s\"], \"fr\"\n )\n if \"en_abstract_s\" in doc.keys():\n if isinstance(doc[\"en_abstract_s\"], list):\n doc[\"en_abstract_s\"] = \"/n\".join(doc[\"en_abstract_s\"])\n if len(doc[\"en_abstract_s\"]) > 100:\n doc[\"en_entites\"] = keyword_enrichissement.return_entities(\n doc[\"en_abstract_s\"], \"en\"\n )\n doc[\"en_teeft_keywords\"] = keyword_enrichissement.keyword_from_teeft(\n doc[\"en_abstract_s\"], \"en\"\n )\n\n doc[\"_id\"] = doc[\"docid\"]\n doc[\"validated\"] = True\n\n doc[\"harvested_from\"] = \"researcher\"\n\n doc[\"harvested_from_ids\"] = []\n doc[\"harvested_from_label\"] = []\n\n #\n #\n # print(doc[\"authorship\"], doc ['authLastName_s'])\n\n if len(doc[\"authIdHal_s\"]) != len(doc[\"authLastName_s\"]):\n # print (\"elastichal.py : test d'autorat no good\")\n # test sur le nom complet...\n nom = [\n truc\n for truc in doc[\"authLastName_s\"]\n if chercheur[\"lastName\"].lower() in truc.lower()\n ] # pour les récemment mariés qui auraient un nom composé...\n # Après si 'lun des co-auteur porte le même nom...\n if len(nom) > 0:\n nom = nom[0].title()\n try:\n if doc[\"authLastName_s\"].index(nom) == 0: # premier\n doc[\"authorship\"] = [\n {\"authorship\": \"firstAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n elif (\n doc[\"authLastName_s\"].index(nom) == len(doc[\"authLastName_s\"]) - 1\n ): # dernier\n doc[\"authorship\"] = [\n {\"authorship\": \"lastAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n except ValueError:\n doc[\"authorship\"] = []\n else:\n doc[\"authorship\"] = []\n elif chercheur[\"halId_s\"] in doc[\"authIdHal_s\"]:\n if doc[\"authIdHal_s\"].index(chercheur[\"halId_s\"]) == 0:\n doc[\"authorship\"] = [\n {\"authorship\": \"firstAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n elif (\n doc[\"authIdHal_s\"].index(chercheur[\"halId_s\"]) == len(doc[\"authIdHal_s\"]) - 1\n ): # dernier\n doc[\"authorship\"] = [\n {\"authorship\": \"lastAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n else:\n doc[\"authorship\"] = []\n else:\n doc[\"authorship\"] = []\n\n doc[\"harvested_from_ids\"].append(chercheur[\"halId_s\"])\n\n # historique d'appartenance du docId\n # pour attribuer les bons docs aux chercheurs\n # harvet_history.append({'docid': doc['docid'], 'from': row['halId_s']})\n #\n # for h in harvet_history:\n # if h['docid'] == doc['docid']:\n # if h['from'] not in doc[\"harvested_from_ids\"]:\n # doc[\"harvested_from_ids\"].append(h['from'])\n\n doc[\"records\"] = []\n\n doc[\"MDS\"] = utils.calculate_mds(doc)\n\n try:\n should_be_open = utils.should_be_open(doc)\n if should_be_open == 1:\n doc[\"should_be_open\"] = True\n if should_be_open == -1:\n doc[\"should_be_open\"] = False\n\n if should_be_open == 1 or should_be_open == 2:\n doc[\"isOaExtra\"] = True\n elif should_be_open == -1:\n doc[\"isOaExtra\"] = False\n except IndexError:\n print(\"publicationDate_tdate error ?\")\n doc[\"Created\"] = datetime.datetime.now().isoformat()\n\n if not init: # récupération de l'existant pour ne pas écraser\n field = \"_id\"\n doc_param = esActions.scope_p(field, doc[\"_id\"])\n\n if not es.indices.exists(\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\"\n ): # -researchers\" + row[\"ldapId\"] + \"-documents\n print(\"exception \", chercheur[\"labHalId\"], chercheur[\"ldapId\"])\n\n res = es.search(\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\",\n body=doc_param,\n ) # -researchers\" + row[\"ldapId\"] + \"-documents\n\n if len(res[\"hits\"][\"hits\"]) > 0:\n doc[\"validated\"] = res[\"hits\"][\"hits\"][0][\"_source\"][\"validated\"]\n if \"authorship\" in res[\"hits\"][\"hits\"][0][\"_source\"]:\n doc[\"authorship\"] = res[\"hits\"][\"hits\"][0][\"_source\"][\"authorship\"]\n\n if (\n res[\"hits\"][\"hits\"][0][\"_source\"][\"modifiedDate_tdate\"]\n != doc[\"modifiedDate_tdate\"]\n ):\n doc[\"records\"].append(\n {\n \"beforeModifiedDate_tdate\": doc[\"modifiedDate_tdate\"],\n \"MDS\": res[\"hits\"][\"hits\"][0][\"_source\"][\"MDS\"],\n }\n )\n\n else:\n doc[\"validated\"] = True\n progress_recorder.set_progress(num, len(docs), description=\"(récolte)\")\n progress_recorder.set_progress(num, len(docs), description=\"(indexation)\")\n helpers.bulk(\n es,\n docs,\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\",\n refresh=\"wait_for\",\n )\n\n return chercheur # au cas où","def stop_word(w): # local feature\n return (w in swl)","def init_ngrams(self):\n self.wv.ngrams = {}\n all_ngrams = []\n self.wv.syn0 = np.zeros((len(self.wv.vocab), self.vector_size), dtype=REAL)\n\n for w, vocab in self.wv.vocab.items():\n all_ngrams += compute_ngrams(w, self.wv.min_n, self.wv.max_n)\n self.wv.syn0[vocab.index] += np.array(self.wv.syn0_ngrams[vocab.index])\n\n all_ngrams = set(all_ngrams)\n self.num_ngram_vectors = len(all_ngrams)\n ngram_indices = []\n for i, ngram in enumerate(all_ngrams):\n ngram_hash = ft_hash(ngram)\n ngram_indices.append(len(self.wv.vocab) + ngram_hash % self.bucket)\n self.wv.ngrams[ngram] = i\n self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)\n\n ngram_weights = self.wv.syn0_ngrams\n\n logger.info(\n \"loading weights for %s words for fastText model from %s\",\n len(self.wv.vocab), self.file_name\n )\n\n for w, vocab in self.wv.vocab.items():\n word_ngrams = compute_ngrams(w, self.wv.min_n, self.wv.max_n)\n for word_ngram in word_ngrams:\n self.wv.syn0[vocab.index] += np.array(ngram_weights[self.wv.ngrams[word_ngram]])\n\n self.wv.syn0[vocab.index] /= (len(word_ngrams) + 1)\n logger.info(\n \"loaded %s weight matrix for fastText model from %s\",\n self.wv.syn0.shape, self.file_name\n )","def exposedSurf(self):\n if self.precision:\n h = self.evaluations.exposedWing.edges[1].point1.x # height of trapezoid\n B = self.chordRootW # major base of trapezoid\n b = self.evaluations.chordIntersected.edges[1].length # minor base of trapezoid\n internalS = 2 * (0.5 * (b + B) * h) # wing surface internal at fuselage\n return self.surfaceW - internalS\n else:\n return self.surfaceW - self.fuselageDiameter * self.cMACW # first guess for a faster evaluation","def v(w,s):\n return w","def compare_wavs_length(c_wv, s_wv):\n\n # If the style wav is shorter than the content wav, exit in error\n if s_wv.shape[0] < c_wv.shape[0]:\n raise WavError(\"The style wav must be as long or longer than the content wav\")\n\n # If the style wav is longer, truncate it to match the content length\n elif s_wv.shape[0] > c_wv.shape[0]:\n print(\"Truncating style wav to match content wav length\")\n s_wv = np.copy(s_wv[:c_wv.shape[0],:])\n\n return s_wv","def build_vocab(self, corpus):\n if self.vocabulary_counts != None:\n logger.debug(\"building vocabulary from provided frequency map\")\n vocab = self.vocabulary_counts\n else:\n logger.debug(\"default vocabulary building\")\n super(Skipgram, self).build_vocab(corpus)\n return\n\n # assign a unique index to each word\n self.vocab, self.index2word = {}, []\n\n for word, count in vocab.iteritems():\n v = Vocab()\n v.count = count\n if v.count >= self.min_count:\n v.index = len(self.vocab)\n self.index2word.append(word)\n self.vocab[word] = v\n\n logger.debug(\"total %i word types after removing those with count<%s\" % (len(self.vocab), self.min_count))\n\n if self.hs:\n # add info about each word's Huffman encoding\n self.create_binary_tree()\n if self.negative:\n # build the table for drawing random words (for negative sampling)\n self.make_table()\n # precalculate downsampling thresholds\n self.precalc_sampling()\n self.reset_weights()","def calc_doc_ret_MAP():\n \n# docs_norm_scores_dicts_path = linux_base_path+\"/docs_norm_scores_dicts\"\n claim_rel_docno_dict = read_pickle(\"claim_rel_docno_dict\") #key is clm, value is a set of the relevant docno\n# nDCG_MAP_res = base_path +\"\\\\nDCG_MAP_res\\\\\"\n# docs_norms_path = base_path+\"\\\\docs_norm_scores_dicts\\\\\"\n docs_norms_path = linux_base_path+\"/docs_norm_scores_dicts/\"\n nDCG_MAP_res = linux_base_path +\"/nDCG_MAP_res/\"\n \n AP_cut_off = 1000\n k_val = 100\n p = 10\n log = open(\"calc_doc_avg_nDCG_MAP_log_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),\"wb\")\n res_file = open(nDCG_MAP_res+\"doc_ret_nDCG_MAP_res_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),\"wb\")\n# each_params_AVGnDCG_MAP_dict = {} #key is alpha,beta,k_docs,lambda and val is the avg nDCG and MAP across all claims together\n each_params_MAP_dict = {}\n# NDCG_AP_all_claims_all_param_values = {}\n AP_all_claims_all_param_values = {}\n best_avg_nDCG = 0\n best_MAP = 0 #across all claims in a given configuration, find the max measures\n \n# docs_norms_path = base_path+\"\\\\docs_norm_scores_dicts\\\\\"\n claims_dict = read_pickle(\"claim_dict\")\n #count the number of sentences that were retrived that are in the true data....sum for each claim, then average.\n \n \n for alpha in range(0,11,1): #change just for test!\n for beta in range(0,10,1):\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\n NDCG_all_claims= {} #key is a claim, value is the nDCG\n AP_all_claims= {} \n AP_cut_off = 1000\n curr_filename = docs_norms_path+\"clm_key_ranked_list_of_docs_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)\n clm_key_ranked_list_of_docs_baseline = read_pickle(curr_filename) #key is qID and docid\n #need to turn it to a list of docs\n for clm in claim_list:\n try:\n# nDCG_score = utils_linux.calc_doc_emp_NDCG(curr_source,str(clm),clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]],p)\n# NDCG_all_claims[clm] = nDCG_score\n AP_score = utils_linux.calc_doc_AP_relevance(AP_cut_off,curr_source,clm,clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]])\n AP_all_claims[clm] = AP_score\n AP_all_claims_all_param_values[clm,alpha_f,beta_f,k_val] = AP_score\n except Exception as err: \n log.write('problem in calculations: in source: '+ curr_source+' in clm '+ claims_dict[str(clm)]+\" alpha:\"+str(alpha_f)+ \"beta:\"+str(beta_f)+\" \\n\" ) \n for arg in err.args:\n log.write(arg+\" \") \n log.write(\"\\n\") \n# average_NDCG = float(float(sum(NDCG_all_claims.values()))/float(len(NDCG_all_claims))) #across all claims...\n# if average_NDCG > best_avg_nDCG:\n# best_avg_nDCG = average_NDCG\n# best_avg_nDCG_configuration = (alpha_f,beta_f,k_val)\n MAP = float(float(sum(AP_all_claims.values()))/float(len(AP_all_claims)))\n if MAP > best_MAP:\n best_MAP = MAP\n best_MAP_configuration = (alpha_f,beta_f,k_val)\n each_params_MAP_dict[alpha_f,beta_f,k_val] = MAP\n utils_linux.save_pickle(nDCG_MAP_res+\"doc_ret_NDCG_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"_at_\"+str(p),NDCG_all_claims)\n utils_linux.save_pickle(nDCG_MAP_res+\"doc_ret_AP_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val),AP_all_claims)\n# res_file.write(\"alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"|\"+\"AnDCG_\"+str(average_NDCG)+\"_MAP_\"+str(MAP)+\"\\n\")\n res_file.write(\"alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"|_MAP_\"+str(MAP)+\"\\n\")\n save_pickle(nDCG_MAP_res+\"doc_ret_NDCG_AP_all_claims_all_param_values_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),AP_all_claims_all_param_values)\n save_pickle(nDCG_MAP_res+\"doc_ret_each_params_AVGnDCG_MAP_dict_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),each_params_MAP_dict)\n# best_row = \"best_avg_nDCG|\"+str(best_avg_nDCG)+\"|best_avg_nDCG_configuration|\"+str(best_avg_nDCG_configuration[0])+\",\"+str(best_avg_nDCG_configuration[1])+\",\"+str(best_avg_nDCG_configuration[3])+\",\"+str(best_avg_nDCG_configuration[2])+\"|\"\n best_row = \"best_MAP|\" +str(best_MAP)+\"|best_MAP_configuration|\"+str(best_MAP_configuration[0])+\",\"+str(best_MAP_configuration[1])+\",\"+str(best_MAP_configuration[2])\n res_file.write(best_row)\n res_file.close()\n log.close()","def documento():\r\n\tpass","def qwf(self, vw, ev, gp, psi_l, lai, dt):\n\t\t#if the amount of water in storage is less than amount that will be absorbed by plant in timestep dt, then what's left will be absorbed \n\t qw = (self.gwf(self.psi_wf(self.vw,self.d1, self.d1, self.ns, self.tl), self.H, self.J)*(self.psi_wf(self.vw, self.d1, self.d1, self.ns, self.tl) - (ev*(1. - self.F_CAP))/(lai*gp) - psi_l)*lai)\n\t if self.vw == 0:\n\t return 0.\n\t elif self.vw*10**6 <= qw*dt:\n\t return (self.vw*10**6/dt)\n\t else:\n\t return qw","def _compute_export_in_woo(self):\n for rec in self:\n rec.ks_export_in_woo = bool(rec.ks_woo_id)","def test_continue_build() -> None:\n tknzr = WsTknzr(is_uncased=True, max_vocab=-1, min_count=0)\n tknzr.build_vocab(['a'])\n tknzr.build_vocab(['b'])\n tknzr.build_vocab(['c'])\n assert tknzr.tk2id == {\n BOS_TK: BOS_TKID,\n EOS_TK: EOS_TKID,\n PAD_TK: PAD_TKID,\n UNK_TK: UNK_TKID,\n 'a': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 1,\n 'b': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 2,\n 'c': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 3,\n }","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def evaluate():\n global dictionary, wv\n count = 0\n # To save the scores by distance and similarity\n scores = np.zeros(6)\n similar = np.zeros(6)\n itr = len(dictionary)\n logging.info('running evaluation for {0} samples'.format(itr))\n for key in dictionary:\n progress = (count / itr) * 100\n d = dictionary[key].split('resource/')\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\n try:\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\n dtype=np.float32)\n except KeyError:\n itr -= 1\n continue\n if np.any(np.isnan(r)):\n itr -= 1\n continue\n else:\n if r.ndim == 2:\n try:\n # Mean of vector containing all word vectors\n # obtained from abstract.\n r = r.mean(axis=0).reshape(1, -1)\n \n # Obtain the vectors for the entity\n mean_vec = mean_encoder(dictionary[key])\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\n mean_dist_vec = distance_encoder(dictionary[key])\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\n title_vec = title_mean(key)\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\n abstract_vec = abstract_encoder(key)\n abstract_vec = abstract_vec.reshape(1, -1)\n abstract_vec = abstract_vec / norm(abstract_vec)\n random_vec = np.random.randn(100).reshape(1, -1)\n zero_vec = np.zeros(100).reshape(1, -1)\n \n # Score the entity vectors\n scores[0] += norm(r - mean_vec)\n scores[1] += norm(r - mean_dist_vec)\n scores[2] += norm(r - title_vec)\n scores[3] += norm(r - abstract_vec)\n scores[4] += norm(r - random_vec)\n scores[5] += norm(r - zero_vec)\n similar[0] += cosine_similarity(r, mean_vec)\n similar[1] += cosine_similarity(r, mean_dist_vec)\n similar[2] += cosine_similarity(r, title_vec)\n similar[3] += cosine_similarity(r, abstract_vec)\n similar[4] += cosine_similarity(r, random_vec)\n similar[5] += cosine_similarity(r, zero_vec)\n count += 1\n print(count, end='\\r')\n except (ValueError, KeyError) as _:\n itr -= 1\n continue\n else:\n itr -= 1\n continue\n # Normalize the scores to get a better\n # comparison against the baselines.\n scores = scores / norm(scores)\n similar = similar / norm(similar)\n print_summary(scores, similar)","def _derW(self, w, x, y, z):\n if _isscalar(w):\n w_pos = max(min(self.wSearchFunc(self.w_list, w), self.w_n - 1), 1)\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\n else:\n w_pos = self.wSearchFunc(self.w_list, w)\n w_pos[w_pos < 1] = 1\n w_pos[w_pos > self.w_n - 1] = self.w_n - 1\n x_pos = self.xSearchFunc(self.x_list, x)\n x_pos[x_pos < 1] = 1\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\n y_pos = self.ySearchFunc(self.y_list, y)\n y_pos[y_pos < 1] = 1\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n z_pos = self.zSearchFunc(self.z_list, z)\n z_pos[z_pos < 1] = 1\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\n i = w_pos # for convenience\n j = x_pos\n k = y_pos\n l = z_pos\n beta = (x - self.x_list[j - 1]) / (self.x_list[j] - self.x_list[j - 1])\n gamma = (y - self.y_list[k - 1]) / (self.y_list[k] - self.y_list[k - 1])\n delta = (z - self.z_list[l - 1]) / (self.z_list[l] - self.z_list[l - 1])\n dfdw = (\n (\n (1 - beta)\n * (1 - gamma)\n * (1 - delta)\n * self.f_values[i, j - 1, k - 1, l - 1]\n + (1 - beta) * (1 - gamma) * delta * self.f_values[i, j - 1, k - 1, l]\n + (1 - beta) * gamma * (1 - delta) * self.f_values[i, j - 1, k, l - 1]\n + (1 - beta) * gamma * delta * self.f_values[i, j - 1, k, l]\n + beta * (1 - gamma) * (1 - delta) * self.f_values[i, j, k - 1, l - 1]\n + beta * (1 - gamma) * delta * self.f_values[i, j, k - 1, l]\n + beta * gamma * (1 - delta) * self.f_values[i, j, k, l - 1]\n + beta * gamma * delta * self.f_values[i, j, k, l]\n )\n - (\n (1 - beta)\n * (1 - gamma)\n * (1 - delta)\n * self.f_values[i - 1, j - 1, k - 1, l - 1]\n + (1 - beta)\n * (1 - gamma)\n * delta\n * self.f_values[i - 1, j - 1, k - 1, l]\n + (1 - beta)\n * gamma\n * (1 - delta)\n * self.f_values[i - 1, j - 1, k, l - 1]\n + (1 - beta) * gamma * delta * self.f_values[i - 1, j - 1, k, l]\n + beta\n * (1 - gamma)\n * (1 - delta)\n * self.f_values[i - 1, j, k - 1, l - 1]\n + beta * (1 - gamma) * delta * self.f_values[i - 1, j, k - 1, l]\n + beta * gamma * (1 - delta) * self.f_values[i - 1, j, k, l - 1]\n + beta * gamma * delta * self.f_values[i - 1, j, k, l]\n )\n ) / (self.w_list[i] - self.w_list[i - 1])\n return dfdw","def _get_context_from_gdoc(self, key):\n try:\n content = self.export_xlsx(key)\n data = process_xlsx(content)\n if 'values' in data:\n data = copy_global_values(data)\n return data\n except BadStatusLine:\n # Stale connection, reset API and data\n puts(\"Connection reset, reloading drive API\")\n self.client = get_drive_api()\n return self._get_context_from_gdoc(key)","def test_validate_wc3(self):\r\n assert self.wc2_tree != 0","def w(self): # pylint: disable=invalid-name\n return self._w","def vwf(self, vw, ev, gp, psi_l, lai, dt):\n\t return min(vw - self.qwf(self.vw, self.th, self.gp, self.psi_l, self.LAI, dt)*dt/10.**6, self.ZW)","def computeProportionWings(self):\n self.ws_me_pointsA = []\n self.ws_me_pointsIy = []\n self.ws_me_pointsIz = []\n self.ws_me_pointsJ = []\n for i in range(self.nWings):\n wingIndex = i+1\n wingNnodes = self.settings[\"wing\"+str(wingIndex)][\"FEM\"][\"nodesFEM\"]\n if self.tigl.wingGetSymmetry(i+1) != 0:\n wingNnodes = 2*wingNnodes - 1\n inputMaxA = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"A\"]\n inputMaxIy = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"Iy\"]\n inputMaxIz = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"Iz\"]\n inputMaxJ = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"J\"]\n inputInterpolationType = self.settings[\"wing\"+str(wingIndex)][\"FEM\"][\"mechanicalInterpolationType\"]\n index = np.argmax(self.ws_me_pointsInitArea[i])\n wingMaxArea = self.ws_me_pointsInitArea[i][index]\n\n if inputInterpolationType == \"constant\":\n exposant = 0\n elif inputInterpolationType == \"linear\":\n exposant = 1\n elif inputInterpolationType == \"quadratic\":\n exposant = 2\n else:\n logger.error(\"Wing mechanical properties distribution is\")\n logger.error(\"wrong. Accepted values are \\\"constant\\\",\")\n logger.error(\"\\\"linear\\\", \\\"quadratic\\\"\")\n sys.exit()\n\n coef = np.empty(wingNnodes)\n self.w_m_pointsA = np.empty(wingNnodes)\n self.w_m_pointsIy = np.empty(wingNnodes)\n self.w_m_pointsIz = np.empty(wingNnodes)\n self.w_m_pointsJ = np.empty(wingNnodes)\n for j in range(wingNnodes):\n coef[j] = self.ws_me_pointsInitArea[i][j]/wingMaxArea\n self.w_m_pointsA[j] = inputMaxA * coef[j]\n self.w_m_pointsIy[j] = inputMaxIy * coef[j]**exposant\n self.w_m_pointsIz[j] = inputMaxIz * coef[j]**exposant\n self.w_m_pointsJ[j] = inputMaxJ * coef[j]**exposant\n self.ws_me_pointsA.append(self.w_m_pointsA)\n self.ws_me_pointsIy.append(self.w_m_pointsIy)\n self.ws_me_pointsIz.append(self.w_m_pointsIz)\n self.ws_me_pointsJ.append(self.w_m_pointsJ)","def processVS(self, model=\"okapi\", l = 0.5):\n self.results[model] = {}\n for query in self.queries:\n res = {}\n for doc in query.docs.values():\n sum_otf = 0.0\n for term in doc.terms:\n if model == \"okapi\":\n sum_otf += self.okapiTF(term.tf, doc.dlen, self.avgdlen)\n if model == \"tfidf\":\n sum_otf += self.tfidf(term.tf, term.df, doc.dlen, self.avgdlen, self.num_docs)\n if model == \"bm25\":\n sum_otf += self.bm25(term.tf, term.df, query.query_tf[term.term], doc.dlen, self.avgdlen, self.num_docs)\n res[doc.id] = sum_otf\n self.results[model][query.id] = res","def unknown(self, w):\n return True","def generate_wordcloud():\r\n # \"\"\"Join list into one string\"\"\"\r\n # unique_string = (\" \").join(prioritized)\r\n # wc = WordCloud(background_color=\"black\", width=2000, height=2000,contour_color=\"black\", max_words=30, relative_scaling=0.5, normalize_plurals=False).generate(unique_string)\r\n\r\n \"\"\"Generate word cloud based on dictionary\"\"\"\r\n wc = WordCloud(background_color=\"black\", width=2000, height=2000, contour_color=\"black\", max_words=30,\r\n relative_scaling=0.5, normalize_plurals=False).generate_from_frequencies(priority_dict)\r\n\r\n fig = plt.figure(figsize=(10, 7))\r\n fig.suptitle(\"Top 30 Most Visited Websites\")\r\n plt.imshow(wc, interpolation=\"bilinear\")\r\n plt.axis(\"on\")\r\n plt.show()","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 w(self):\n return self._w","def filter_w2v_nomenclature(w2vfilename,filter_nomenclature):\n V = set(filter_nomenclature)\n wordlist = []\n veclist = [] \n istream = open(w2vfilename)\n istream.readline() #skips w2v header\n for line in istream:\n fields = line.split()\n word = fields[0]\n if word in V:\n vec = np.array([float(elt) for elt in fields[1:]])\n wordlist.append(word)\n veclist.append(vec)\n istream.close()\n M = np.array(veclist)\n return (wordlist,M)","def check_for_correction(dummy_arg):\n #space_indexes = []\n #new_space_indexes = []\n #punct_dict = {}\n\n # Get current document and attributes for doc\n doc = XSCRIPTCONTEXT.getDocument()\n selection_supplier = doc.getCurrentController()\n indexAccess = selection_supplier.getSelection()\n #count = indexAccess.getCount() # don't really need this right now. Only loop once..\n\n # get cursor to write corrected word highlighted in blue\n text = doc.Text\n vis_cursor = doc.getCurrentController().getViewCursor() # visible cursor in OpenOffice\n nvis_cursor= vis_cursor.getText().createTextCursorByRange(vis_cursor) # not visible cursor place at same place as visible\n \n # set str and txt for use\n highlighted_txt = indexAccess.getByIndex(0)\n highlighted_str = highlighted_txt.getString()\n \n # strip punctuation from string\n punctuation = set(string.punctuation)\n '''\n for letter in highlighted_str:\n if letter == ' ':\n sp_index = highlighted_str.index(letter)\n space_indexes.append(sp_index + len(space_indexes))\n highlighted_str = highlighted_str.replace(letter,'',1)\n \n for index in space_indexes:\n highlighted_str = highlighted_str[:index] + ' ' + highlighted_str[index:]\n\n \n for letter in highlighted_str:\n if letter in punctuation:\n punc_index = highlighted_str.index(letter)\n punct_dict[letter] = punc_index\n highlighted_str = highlighted_str.replace(letter,'',1)\n '''\n highlighted_str = ''.join(ch for ch in highlighted_str if ch not in punctuation) \n highlighted_str_arr = highlighted_str.split()\n\n corrected_sent = highlighted_str # correct sentence to be displayed at end\n\n # check for correction for each word highlighted\n for word in highlighted_str_arr:\n\n if len(highlighted_str) == 0:\n return None\n\n # call make_correction helper function to correct highlighted word\n else:\n correction = make_correction(word)\n \n # make sure new correction word is present\n if correction:\n # get parent window from document\n parentwin = doc.CurrentController.Frame.ContainerWindow\n # make window\n correction_query_str = word + \" => \" + correction # show old word => new word\n prompt = MessageBox(parentwin, correction_query_str, \"Correction:\", MESSAGEBOX, BUTTONS_YES_NO)\n \n # if yes button pressed, replace word\n if prompt == 2:\n # replace wrong word with corrected word\n corrected_sent = corrected_sent.replace(word, correction)\n '''\n for letter in corrected_sent:\n if letter == ' ':\n sp_index = corrected_sent.index(letter)\n new_space_indexes.append(sp_index + len(new_space_indexes))\n corrected_sent = corrected_sent.replace(letter,'',1)\n \n for index in new_space_indexes:\n corrected_sent = corrected_sent[:index] + ' ' + corrected_sent[index:]\n \n \n punc_location = {}\n for key in punct_dict:\n p_index = punct_dict[key]\n for s_index in space_indexes:\n if abs(p_index-s_index) == 1:\n location_index = space_indexes.index(s_index)\n if p_index-s_index > 0:\n punc_location[key] = new_space_indexes[location_index+1]\n else:\n punc_location[key] = new_space_indexes[location_index-1]\n\n\n for key in punc_location:\n index = punc_location[key]\n corrected_sent = key\n #corrected_sent = corrected_sent[:index] + key + corrected_sent[index:]\n ''' \n #highlighted_txt.setString(highlighted_str)\n highlighted_txt.setString(corrected_sent) # replace old word with nothing"],"string":"[\n \"def get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode):\\r\\n cnt_list =[]\\r\\n for b, g_wc1 in enumerate(g_wc):\\r\\n pr_wn1 = len(pr_sql_i[b][\\\"conds\\\"])\\r\\n g_wn1 = g_wn[b]\\r\\n\\r\\n # Now sorting.\\r\\n # Sort based wc sequence.\\r\\n if mode == 'test':\\r\\n idx1 = argsort(array(g_wc1))\\r\\n elif mode == 'train':\\r\\n idx1 = list( range( g_wn1) )\\r\\n else:\\r\\n raise ValueError\\r\\n\\r\\n if g_wn1 != pr_wn1:\\r\\n cnt_list.append(0)\\r\\n continue\\r\\n else:\\r\\n flag = True\\r\\n for i_wn, idx11 in enumerate(idx1):\\r\\n g_wvi_str11 = str(g_sql_i[b][\\\"conds\\\"][idx11][2]).lower()\\r\\n pr_wvi_str11 = str(pr_sql_i[b][\\\"conds\\\"][i_wn][2]).lower()\\r\\n # print(g_wvi_str11)\\r\\n # print(pr_wvi_str11)\\r\\n # print(g_wvi_str11==pr_wvi_str11)\\r\\n if g_wvi_str11 != pr_wvi_str11:\\r\\n flag = False\\r\\n # print(g_wv1, g_wv11)\\r\\n # print(pr_wv1, pr_wv11)\\r\\n # input('')\\r\\n break\\r\\n if flag:\\r\\n cnt_list.append(1)\\r\\n else:\\r\\n cnt_list.append(0)\\r\\n\\r\\n return cnt_list\",\n \"def _compute_wo(self):\\n self.uom_id = self.wo_id.uom_id.id\\n self.final_product_id = self.wo_id.final_product_id.id\\n if not self.supplier_id:\\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\\n else:\\n service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\\n if service_ids:\\n product_supp_rcs = self.env['product.supplierinfo'].search([('partner_id', '=', self.supplier_id.id), ('product_id', 'in', service_ids)])\\n if product_supp_rcs:\\n product_ids = [x.product_id.id for x in product_supp_rcs if x.product_id]\\n else:\\n product_ids = []\\n else:\\n product_ids = [] \\n \\n self.service_ids = product_ids\\n \\n # Permet de savoir si l'OT suivant est de sous-traitance et qu'il y a qu'un seul OT suivant\\n no_direct_fp = True\\n if self.wo_id.next_wo_ids and len(self.wo_id.next_wo_ids) == 1 and self.wo_id.next_wo_ids[0].is_subcontracting and self.wo_id.next_wo_ids[0].consumed_service_ids:\\n no_direct_fp = False\\n \\n self.no_direct_fp = no_direct_fp\",\n \"def convert_pr_wvi_to_string(pr_wvi, nlu_t, nlu_wp_t, wp_to_wh_index, nlu):\\r\\n pr_wv_str_wp = [] # word-piece version\\r\\n pr_wv_str = []\\r\\n for b, pr_wvi1 in enumerate(pr_wvi):\\r\\n pr_wv_str_wp1 = []\\r\\n pr_wv_str1 = []\\r\\n wp_to_wh_index1 = wp_to_wh_index[b]\\r\\n nlu_wp_t1 = nlu_wp_t[b]\\r\\n nlu_t1 = nlu_t[b]\\r\\n\\r\\n for i_wn, pr_wvi11 in enumerate(pr_wvi1):\\r\\n st_idx, ed_idx = pr_wvi11\\r\\n\\r\\n # Ad-hoc modification of ed_idx to deal with wp-tokenization effect.\\r\\n # e.g.) to convert \\\"butler cc (\\\" ->\\\"butler cc (ks)\\\" (dev set 1st question).\\r\\n pr_wv_str_wp11 = nlu_wp_t1[st_idx:ed_idx+1]\\r\\n pr_wv_str_wp1.append(pr_wv_str_wp11)\\r\\n\\r\\n st_wh_idx = wp_to_wh_index1[st_idx]\\r\\n ed_wh_idx = wp_to_wh_index1[ed_idx]\\r\\n pr_wv_str11 = nlu_t1[st_wh_idx:ed_wh_idx+1]\\r\\n\\r\\n pr_wv_str1.append(pr_wv_str11)\\r\\n\\r\\n pr_wv_str_wp.append(pr_wv_str_wp1)\\r\\n pr_wv_str.append(pr_wv_str1)\\r\\n\\r\\n return pr_wv_str, pr_wv_str_wp\",\n \"def unknown(self, w):\\n # WORK HERE!!\",\n \"def _compute_wo(self):\\n self.uom_id = self.wo_id.uom_id.id\\n self.final_product_id = self.wo_id.final_product_id.id\\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\",\n \"def get_wm_ws_Gx_bot(self):\\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \\n z_u_r = self.grid_dict['z_u_r']\\n z_u_w = self.grid_dict['z_u_w']\\n [Ly,N] = self.b.shape\\n #---> j-loop\\n for j in range(Ly): \\n self.kbl[j] = N # initialize search\\n #-> end j-loop\\n\\n #--> k-loop\\n for k in range(N-1,0,-1):\\n k_w = k\\n k_r = k-1\\n # --> j loop \\n for j in range(Ly):\\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\\n self.kbl[j] = k_w\\n\\n #--> end k\\n # --> end j\\n\\n\\n '''\\n Compute nondimenisonal shape function coefficeints Gx() by\\n matching values and vertical derivatives of interior mixing\\n coefficients at hbbl (sigma=1)\\n '''\\n\\n self.Gm1_bot = np.zeros([Ly])\\n self.dGm1_dS_bot = np.zeros([Ly])\\n self.Gt1_bot = np.zeros([Ly])\\n self.dGt1_dS_bot = np.zeros([Ly]) \\n self.Av_bl_bot = np.zeros([Ly])\\n self.dAv_bl_bot = np.zeros([Ly]) \\n self.cff_up_bot = np.zeros([Ly])\\n self.cff_dn_bot = np.zeros([Ly])\\n\\n\\n\\n\\n\\n self.wm_bot = np.zeros([Ly])\\n self.ws_bot = np.zeros([Ly]) \\n\\n # CALCULATE ustar for the bottom based on bototm velocities\\n \\n \\n \\n # CALCULATE r_D\\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \\n u = self.u\\n v_upts = TTTW_func.v2u(self.v)\\n \\n ubar = np.mean(u,axis=1)\\n vbar = np.mean(v_upts,axis=1)\\n\\n # --> j loop\\n for j in range(Ly):\\n # turbulent velocity sclaes with buoyancy effects neglected\\n if self.CD_SWITCH:\\n # DEPTH AVERAGED APPROACH\\n uref = u[j,0]\\n vref = v_upts[j,0]\\n ustar2 = self.C_D * (uref**2 + vref**2)\\n else:\\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\\n wm = self.vonKar * np.sqrt(ustar2)\\n ws = wm\\n\\n self.wm_bot[j] = wm\\n self.ws_bot[j] = ws\\n \\n k_w = self.kbl[j] \\n z_bl = z_u_w[j,0] + self.hbbl[j]\\n\\n if z_bl < z_u_w[j,k_w-1]:\\n k_w = k_w-1\\n\\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl_bot[j] = Av_bl\\n self.dAv_bl_bot[j] = dAv_bl\\n\\n\\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\\n\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])\",\n \"def grounding_words(self, w):\\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])\",\n \"def wisdom(search_me, source, pdfurl, userid):\\n ### source needs to be name of data source (\\\"arxiv\\\", \\\"google scholar\\\", \\\"doaj\\\")\\n search_me = search_me.strip()\\n # check if pdfurl has been found before\\n pdf = db_summaries.find_one({\\\"url\\\": pdfurl})\\n if pdf:\\n text = pdf.get('text')\\n summary = pdf.get('summary')\\n topics = pdf.get('topics')\\n # update in db if data is 1 days or older\\n last_updated = datetime.utcnow() - pdf.get(\\\"last_updated\\\")\\n last_updated_diff = last_updated.days\\n if last_updated_diff > 1:\\n search_term = db_search_terms.find_one({\\\"value\\\": search_me.lower()})\\n search_id = search_term.get(\\\"_id\\\")\\n data = {\\\"search_id\\\": search_id,\\n \\\"url\\\": pdfurl, \\\"source\\\": source, \\\"text\\\": text,\\n \\\"summary\\\": summary, \\\"topics\\\": topics, \\\"last_updated\\\": datetime.utcnow()}\\n db_summaries.update({\\\"url\\\": pdfurl}, {\\\"$set\\\": data})\\n else:\\n pass\\n else:\\n text = wisdomaiengine.pdfdocumentextracter(pdfurl)\\n summary = wisdomaiengine.summarisepdfdocument(text)\\n topics = wisdomaiengine.wordcloud(search_me, text)\\n if topics is None:\\n topics = ['No Topics Found']\\n # write data to arxiv collection\\n search_term = db_search_terms.find_one({\\\"value\\\": search_me.lower()})\\n search_id = search_term.get(\\\"_id\\\")\\n data = {\\\"search_id\\\": search_id,\\n \\\"url\\\": pdfurl,\\n \\\"source\\\": source,\\n \\\"text\\\": text,\\n \\\"summary\\\": summary,\\n \\\"topics\\\": topics,\\n \\\"last_updated\\\": datetime.utcnow()}\\n x = db_summaries.insert(data, check_keys=False)\\n # return json\\n summaryjson = jsonify(wisdomtopics=topics, wisdomsummary=summary)\\n return summaryjson\",\n \"def get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode):\\r\\n cnt_list =[]\\r\\n for b, g_wvi1 in enumerate(g_wvi):\\r\\n g_wc1 = g_wc[b]\\r\\n pr_wvi1 = pr_wvi[b]\\r\\n pr_wn1 = len(pr_wvi1)\\r\\n g_wn1 = g_wn[b]\\r\\n\\r\\n # Now sorting.\\r\\n # Sort based wc sequence.\\r\\n if mode == 'test':\\r\\n idx1 = argsort(array(g_wc1))\\r\\n elif mode == 'train':\\r\\n idx1 = list( range( g_wn1) )\\r\\n else:\\r\\n raise ValueError\\r\\n\\r\\n if g_wn1 != pr_wn1:\\r\\n cnt_list.append(0)\\r\\n continue\\r\\n else:\\r\\n flag = True\\r\\n for i_wn, idx11 in enumerate(idx1):\\r\\n g_wvi11 = g_wvi1[idx11]\\r\\n pr_wvi11 = pr_wvi1[i_wn]\\r\\n if g_wvi11 != pr_wvi11:\\r\\n flag = False\\r\\n # print(g_wv1, g_wv11)\\r\\n # print(pr_wv1, pr_wv11)\\r\\n # input('')\\r\\n break\\r\\n if flag:\\r\\n cnt_list.append(1)\\r\\n else:\\r\\n cnt_list.append(0)\\r\\n\\r\\n return cnt_list\",\n \"def get_wotd():\\n\\treturn wotd\",\n \"def _get_wred(self):\\n return self.__wred\",\n \"def _get_wred(self):\\n return self.__wred\",\n \"def _get_wred(self):\\n return self.__wred\",\n \"def get_warc(self):\\n raise NotImplementedError()\",\n \"def svn_info_t_has_wc_info_get(svn_info_t_self): # real signature unknown; restored from __doc__\\n pass\",\n \"def wing(self):\\n return\",\n \"def is_wcw(status):\\n test_text = ' '.join(status['text'].lower().split()) # Remove capital letters and excessive whitespace/linebreaks\\n usernames = ['just_to_say_bot', 'thisisjustbot', 'Dcd200S', 'willslostplum', 'sosweetbot', 'JustToSayBot', 'thatisjustplums', \\\\\\n\\t\\t 'EatenBot', 'the_niche_bot', 'KristenCostel10', 'litabottal', 'pythonnina', 'alatest5', 'LisaRob96585017','Stilson28400122', \\\\\\n\\t\\t 'JohnDun40217560','Cordelia28', 'Rick63556459', 'botsnthings', 'timbot301', 'Rachel53001595', 'NicholasMillma6', 'ThisIsJustTo1'\\\\\\n\\t\\t'MayISay4', 'breakfast_plum', 'BotBot53368932'] # Block screen_names of known parody accounts\\n if status['user']['screen_name'] not in usernames and all(u not in status['text'] for u in usernames) and 'Cheap Bots, Done Quick!' not in status['source']:\\n if 'which you were probably' in test_text: # Capture parodies of the form\\n return True\\n elif 'plums' in test_text and 'icebox' in test_text: # Capture parodies of the content\\n return True\\n elif 'plum' in test_text and 'icebox' in test_text: # Capture singular 'plum'\\n return True\\n elif 'plums' in test_text and 'ice box' in test_text: #Capture 'ice box' with a space\\n return True\\n elif 'plum' in test_text and 'ice box' in test_text: \\n return True\\n elif 'William Carlos Williams'.lower() in test_text and 'plums' in test_text: #Capture mentions of WCW\\n return True\\n elif 'William Carlos Williams'.lower() in test_text and 'plum' in test_text:\\n return True\\n elif 'this is just to say' in test_text and 'that were in' in test_text: # Get only relevant instances of \\\"this is just to say\\\"\\n return True\\n elif 'this is just to say' in test_text and 'forgive me' in test_text:\\n return True\\n elif 'this is just to say' in test_text and 'and so' in test_text:\\n return True\\n elif 'so sweet and so cold' in test_text and 'the arms of the ocean' not in test_text: # Get 'so sweet and so cold' tweets that aren't quoting Florence and the Machine\\n return True\\n else:\\n return False\\n else:\\n return False\",\n \"def get_WS(w2v):\\n # get set of MAX_NGRAM-grams in text\\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 ngrams_in_data = set()\\n for words in raw:\\n for ngram in tweet_to_ngrams(words):\\n ngrams_in_data.add(ngram)\\n\\n # load sentiment features from model\\n clf_pipe = pickle.load(open(CLF_FNAME, 'rb')) # model\\n\\n vect = clf_pipe.best_estimator_.named_steps['vect']\\n clf = clf_pipe.best_estimator_.named_steps['clf']\\n\\n features_to_sent_idx = vect.vocabulary_ # map from model features to sentiment index\\n # currently, sentiment = 2 * (count_pos / (count_pos + count_neg)) - 1\\n sentiments = clf.feature_count_[1,:] / np.sum(clf.feature_count_, axis=0) # in [0,1]\\n sentiments = 2 * sentiments - 1 # rescale to [-1,1]\\n\\n features_to_sent = {feat: sentiments[idx] for (feat,idx) in features_to_sent_idx.items()}\\n\\n # build WS and ngram_idx_map for each MAX_NGRAM-gram in the text\\n k = len(next(iter(w2v.values()))) # dimension of embedding\\n WS = np.zeros(shape=(len(ngrams_in_data) + 1, k + MAX_NGRAM), dtype='float32')\\n ngram_idx_map = {}\\n\\n index = 1 # first row is left 0, for padding in the cnn. This is also neutral sentiment.\\n # For Vader Sentiment analysis\\n# vader_analyzer = SentimentIntensityAnalyzer()\\n\\n\\n for ngram in ngrams_in_data:\\n ngram_idx_map[ngram] = index\\n\\n # set word embedding, note that unknown words already randomized in load_embedding \\n words = ngram.split(' ')\\n WS[index,:k] = w2v[words[-1]] # embedding of last word\\n\\n # set sentiment embedding\\n for n in range(MAX_NGRAM): # for 1, 2, ... length ngrams\\n sub_ngram = ' '.join(words[-1 - n:]) \\n\\n # Naive Bayes Sentiment feature --------------------------------\\n sent = features_to_sent.get(sub_ngram, 0.0) # default to neutral 0\\n # --------------------------------------------------------------\\n\\n# # TextBlob sentiment feature -----------------------------------\\n# sent = TextBlob(sub_ngram).sentiment.polarity\\n# # --------------------------------------------------------------\\n\\n# # Vader sentiment feature -------------------------------------\\n# sent = vader_analyzer.polarity_scores(sub_ngram)['compound']\\n# # -------------------------------------------------------------\\n WS[index,k+n] = sent\\n\\n index += 1\\n\\n return WS, ngram_idx_map\",\n \"def combined_wcs(self) -> BaseHighLevelWCS:\",\n \"def handlehtmlsearch_wok(querystring, keywordstring, searchlimit, cache, smartconstrain):\\n mpsearch, keywords, constraints = handlehtmlsearch_mp(querystring, keywordstring, cache, smartconstrain)\\n\\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'rt') as record:\\n try:\\n wlist = json.load(record)\\n except ValueError:\\n wlist = {}\\n\\n searchtotal = 0\\n for search in mpsearch:\\n searchtotal += len(search)\\n\\n wokresults = []\\n i = 0\\n\\n for search in mpsearch:\\n for n in search:\\n iterinput = []\\n for m in n['unit_cell_formula'].keys():\\n iterinput.append(m + str(int(n['unit_cell_formula'][m])))\\n\\n iterlist = list(itertools.permutations(iterinput))\\n\\n searchparam = 'topic:' + n['pretty_formula'] + ' or topic:' + n['full_formula']\\n\\n for term in iterlist:\\n searchparam += ' or topic:' + ''.join(term)\\n\\n i += 1\\n if n['material_id'] in wlist.keys() and cache:\\n print('loading wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\\n wokresults.append(wlist[n['material_id']])\\n else:\\n print('searching wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\\n try:\\n searchdata = searchWoKTools.getsearchdata(searchparam, searchlimit)\\n except:\\n with open('wokRecord.json', 'wt') as record:\\n json.dump(wlist, record)\\n raise\\n\\n searchdata[0].update(n)\\n wlist[n['material_id']] = searchdata\\n wokresults.append(searchdata)\\n\\n mpsearch, wokresults = searchWoKTools.removeconstrainedwok(mpsearch, wokresults, constraints)\\n\\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'wt') as record:\\n json.dump(wlist, record)\\n\\n keyresults = []\\n for search in wokresults:\\n keyresults.append(searchWoKTools.getkeylist(search, keywords))\\n\\n return keywords, mpsearch, wokresults, keyresults\",\n \"def pwgrwlfilter(self):\\n return None\",\n \"def treat_page(self):\\n # let's define some basic variables\\n urtext = self.current_page.text\\n urlang = self.current_page.site.code\\n urtitle = self.current_page.title()\\n urcat = []\\n eng_site = pywikibot.Site('en')\\n eng_title = ''\\n \\n interDict = {}\\n try:\\n site = pywikibot.Site('ur', 'wikipedia')\\n urpage = pywikibot.Page(site, urtitle)\\n langlst = urpage.iterlanglinks()\\n\\n \\n for i in langlst:\\n lang = str(i.site).split(':')[1]\\n interDict[lang] = i.title\\n \\n eng_title = interDict['en']\\n except:\\n pywikibot.output(u'\\\\03{lightred}Unable to fetch interwiki links!\\\\03{default}')\\n return False\\n \\n site = pywikibot.Site('en', 'wikipedia')\\n enpage = pywikibot.Page(site, eng_title)\\n\\n wikitext = enpage.get() \\n wikicode = mwp.parse(wikitext)\\n\\n # Extracting sfn templates and converting them in REF tags\\n sfnlist = []\\n for template in wikicode.filter_templates():\\n if template.name in ('sfn', 'sfn'):\\n sfnlist.append(template)\\n templ_rep = '<ref>' + str(template) + '</ref>'\\n wikicode.replace(template , templ_rep)\\n\\n alltags = wikicode.filter_tags() \\n reftags = {}\\n \\n def search(myDict, search1):\\n for key, value in myDict.items():\\n if search1 in value: \\n return key \\n \\n i=1\\n for tag in alltags:\\n if tag.tag=='ref':\\n if tag.attributes == []: # check if attributes list is empty\\n refval='NoRefName' # Reference has no name so assigning \\\"NoRefName\\\"\\n else:\\n name = tag.attributes[0]\\n refval = name.value\\n \\n if tag.contents is None:\\n #conval = search(reftags,refval)\\n #reftags[i] = (refval,reftags[conval][1])\\n pass\\n else: \\n reftags[i] = (refval,tag.contents)\\n i += 1\\n\\n dlinks = {}\\n for k,v in reftags.items():\\n dkey = 'و' + str(k) + 'و'\\n dlinks[dkey] = '<ref>' + str(v[1]) + '</ref>'\\n\\n urtext = urpage.text\\n for r in tuple(dlinks.items()):\\n urtext = urtext.replace(*r)\\n\\n # newln = '\\\\n'\\n # Using noreferences to add Reference template if not present\\n self.norefbot = noreferences.NoReferencesBot(None)\\n if self.norefbot.lacksReferences(urtext):\\n urtext = self.norefbot.addReferences(urtext)\\n else:\\n urpage.text = urtext + '\\\\n'\\n\\n print(urpage.text)\\n \\n # save the page \\n urpage.save(summary=self.summary, minor=False)\\n #self.put_current(urpage.text, summary=self.summary)\",\n \"def CC_wdw(self):\\n # Setup param\\n loc = 'TSdata'\\n if 'single' == self.newParam['survey_type']:\\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc).shape[0]\\n elif 'multiple' == self.newParam['survey_type']:\\n TS_group = dt.utilities.DB_group_names(self.Database, group_name = loc)[0]\\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc+'/'+TS_group).shape[0]\\n\\n param = self.newParam\\n\\n # Assign TS processing length to end_wdws if given\\n if param['end_wdws']:\\n TS_sig_len = param['end_wdws']\\n else:\\n TS_sig_len = TS_len\\n\\n ERROR_MESSAGE = 'The length of a TS signal to be processed is', TS_sig_len, \\\\\\n 'which is < end of the last window'\\n\\n # Calculate wdwPos for overlapping windows of ww_ol if wdwPos is False\\n if param['wdwPos'][0] is False:\\n # Error checks\\n if TS_sig_len < self.newParam['ww'][0]:\\n raise Warning(ERROR_MESSAGE)\\n\\n wdwStep = np.floor(param['ww'][0] *\\n (100 - param['ww_ol']) / 100)\\n\\n if self.verbose: print('* Length fo TSdata', TS_len)\\n\\n max_wdwPos = TS_sig_len - param['ww'][0] + 1\\n wdwStarts = np.arange(0 + param['sta_wdws'], max_wdwPos, wdwStep).astype(int)\\n\\n if self.verbose: print('* The step in window potions is %s sample points' % wdwStep)\\n if self.verbose: print('* The max window postions is %s sample points'% max_wdwPos)\\n\\n param['wdwPos'] = [ [wdw_start, wdw_start + param['ww'][0]] for\\n wdw_start in wdwStarts ]\\n\\n # Only update wdwPos structure if not already done so\\n elif np.array(param['wdwPos'][0]).shape == ():\\n param['wdwPos'] = [ [wdw_start, wdw_start + ww] for wdw_start,ww in\\n zip(param['wdwPos'], param['ww'])]\\n\\n self.newParam['wdwPos'] = param['wdwPos']\",\n \"def fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw):\\n\\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\\n\\tTocwf=Vk*Ck*Dk/GDen\\n\\treturn Tocwf\",\n \"def buildWPriorTerm(self):\\r\\n\\r\\n # self.w_prior.shape == (minibatch size,)\\r\\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\\r\\n\\r\\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)\",\n \"def wkt(self): # -> str:\\n ...\",\n \"def _new_wos_dict():\\n wos_dict = {\\n 'DI': None,\\n 'TI': None,\\n 'PY': None,\\n 'SO': None,\\n 'UT': None,\\n 'DE': None,\\n }\\n\\n return wos_dict\",\n \"def wing_geom_eval(self, cpacs):\\n\\n log.info(\\\"---------- Analysing wing geometry ----------\\\")\\n\\n # Opening tixi and tigl\\n tixi = cpacs.tixi\\n tigl = cpacs.tigl\\n\\n # Counting wing number without symmetry --------------------------------------\\n w_nb = tixi.getNamedChildrenCount(WINGS_XPATH, \\\"wing\\\")\\n\\n # INITIALIZATION 1 -----------------------------------------------------------\\n self.w_nb = w_nb\\n self.wing_nb = w_nb\\n wing_plt_area_xz = []\\n wing_plt_area_yz = []\\n wingUID = []\\n\\n # Counting sections and segments----------------------------------------------\\n b = 0\\n for i in range(1, w_nb + 1):\\n double = 1\\n self.wing_sym.append(tigl.wingGetSymmetry(i))\\n if self.wing_sym[i - 1] != 0:\\n double = 2 # To consider the real amount of wing\\n # when they are defined using symmetry\\n self.wing_nb += 1\\n self.wing_sec_nb.append(tigl.wingGetSectionCount(i))\\n self.wing_seg_nb.append(tigl.wingGetSegmentCount(i))\\n self.wing_vol.append(tigl.wingGetVolume(i) * double)\\n\\n self.wing_plt_area.append(tigl.wingGetReferenceArea(i, 1) * double) # x-y plane\\n wing_plt_area_xz.append(tigl.wingGetReferenceArea(i, 2) * double) # x-z plane\\n wing_plt_area_yz.append(tigl.wingGetReferenceArea(i, 3) * double) # y-z plane\\n\\n self.wing_tot_vol = self.wing_tot_vol + self.wing_vol[i - 1]\\n wingUID.append(tigl.wingGetUID(i))\\n self.wing_span.append(tigl.wingGetSpan(wingUID[i - 1]))\\n a = np.amax(self.wing_span)\\n # Evaluating the index that corresponds to the main wing\\n if a > b:\\n self.main_wing_index = i\\n b = a\\n\\n # Checking segment and section connection and reordering them\\n (\\n self.wing_sec_nb,\\n _,\\n seg_sec,\\n _,\\n ) = self.wing_check_segment_connection(wing_plt_area_xz, wing_plt_area_yz, tigl)\\n\\n # INITIALIZATION 2 -----------------------------------------------------------\\n\\n max_wing_sec_nb = np.amax(self.wing_sec_nb)\\n max_wing_seg_nb = np.amax(self.wing_seg_nb)\\n wing_center_section_point = np.zeros((max_wing_sec_nb, w_nb, 3))\\n self.wing_center_seg_point = np.zeros((max_wing_seg_nb, self.wing_nb, 3))\\n self.wing_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\\n self.wing_fuel_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\\n self.wing_fuel_vol = 0\\n self.wing_mac = np.zeros((4, w_nb))\\n self.wing_sec_thickness = np.zeros((max_wing_sec_nb + 1, w_nb))\\n\\n # WING ANALYSIS --------------------------------------------------------------\\n\\n # Main wing plantform area\\n self.wing_plt_area_main = self.wing_plt_area[self.main_wing_index - 1]\\n\\n # Wing: MAC,chords,thickness,span,plantform area ------------------------------\\n\\n for i in range(1, w_nb + 1):\\n mac = tigl.wingGetMAC(wingUID[i - 1])\\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, 1, 0.0, 0.0)\\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, 1, 0.0, 1.0)\\n self.wing_max_chord.append(\\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\\n )\\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 0.0)\\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 1.0)\\n self.wing_min_chord.append(\\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\\n )\\n for k in range(1, 5):\\n self.wing_mac[k - 1][i - 1] = mac[k - 1]\\n for jj in range(1, self.wing_seg_nb[i - 1] + 1):\\n j = int(seg_sec[jj - 1, i - 1, 2])\\n cle = tigl.wingGetChordPoint(i, j, 0.0, 0.0)\\n self.wing_seg_vol[j - 1][i - 1] = tigl.wingGetSegmentVolume(i, j)\\n lp = tigl.wingGetLowerPoint(i, j, 0.0, 0.0)\\n up = tigl.wingGetUpperPoint(i, j, 0.0, 0.0)\\n if np.all(cle == lp):\\n L = 0.25\\n else:\\n L = 0.75\\n if np.all(cle == up):\\n U = 0.25\\n else:\\n U = 0.75\\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, j, 0.0, L)\\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, j, 0.0, U)\\n wing_center_section_point[j - 1][i - 1][0] = (wplx + wpux) / 2\\n wing_center_section_point[j - 1][i - 1][1] = (wply + wpuy) / 2\\n wing_center_section_point[j - 1][i - 1][2] = (wplz + wpuz) / 2\\n self.wing_sec_thickness[j - 1][i - 1] = np.sqrt(\\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\\n )\\n j = int(seg_sec[self.wing_seg_nb[i - 1] - 1, i - 1, 2])\\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, self.wing_seg_nb[i - 1], 1.0, L)\\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, self.wing_seg_nb[i - 1], 1.0, U)\\n self.wing_sec_thickness[j][i - 1] = np.sqrt(\\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\\n )\\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][0] = (wplx + wpux) / 2\\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][1] = (wply + wpuy) / 2\\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][2] = (wplz + wpuz) / 2\\n self.wing_sec_mean_thick.append(\\n np.mean(self.wing_sec_thickness[0 : self.wing_seg_nb[i - 1] + 1, i - 1])\\n )\\n # Evaluating wing fuel tank volume in the main wings\\n if abs(round(self.wing_plt_area[i - 1], 3) - self.wing_plt_area_main) < 0.001:\\n tp_ratio = self.wing_min_chord[i - 1] / self.wing_max_chord[i - 1]\\n ratio = round(tp_ratio * self.wing_plt_area[i - 1] / 100, 1)\\n if ratio >= 1.0:\\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.8, 2)\\n elif ratio >= 0.5:\\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.72, 2)\\n else:\\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.5, 2)\\n for j in seg_sec[:, i - 1, 2]:\\n if j == 0.0:\\n break\\n self.wing_fuel_seg_vol[int(j) - 1][i - 1] = round(\\n (self.wing_seg_vol[int(j) - 1][i - 1] / (sum(self.wing_vol)))\\n * self.wing_fuel_vol,\\n 2,\\n )\\n if (\\n self.wing_plt_area[i - 1] > wing_plt_area_xz[i - 1]\\n and self.wing_plt_area[i - 1] > wing_plt_area_yz[i - 1]\\n ):\\n self.is_horiz.append(True)\\n if self.wing_sym[i - 1] != 0:\\n self.is_horiz.append(True)\\n else:\\n self.is_horiz.append(False)\\n if self.wing_sym[i - 1] != 0:\\n self.is_horiz.append(False)\\n\\n # Wing segment length evaluating function\\n self.get_wing_segment_length(wing_center_section_point)\\n\\n # Evaluating the point at the center of each segment, the center\\n # is placed at 1/4 of the chord, symmetry is considered.\\n\\n a = 0\\n c = False\\n for i in range(1, int(self.wing_nb) + 1):\\n if c:\\n c = False\\n continue\\n for jj in range(1, self.wing_seg_nb[i - a - 1] + 1):\\n j = int(seg_sec[jj - 1, i - a - 1, 2])\\n self.wing_center_seg_point[j - 1][i - 1][0] = (\\n wing_center_section_point[j - 1][i - a - 1][0]\\n + wing_center_section_point[j][i - a - 1][0]\\n ) / 2\\n self.wing_center_seg_point[j - 1][i - 1][1] = (\\n wing_center_section_point[j - 1][i - a - 1][1]\\n + wing_center_section_point[j][i - a - 1][1]\\n ) / 2\\n self.wing_center_seg_point[j - 1][i - 1][2] = (\\n wing_center_section_point[j - 1][i - a - 1][2]\\n + wing_center_section_point[j][i - a - 1][2]\\n ) / 2\\n if self.wing_sym[i - 1 - a] != 0:\\n if self.wing_sym[i - 1 - a] == 1:\\n symy = 1\\n symx = 1\\n symz = -1\\n if self.wing_sym[i - 1 - a] == 2:\\n symy = -1\\n symx = 1\\n symz = 1\\n if self.wing_sym[i - 1 - a] == 3:\\n symy = 1\\n symx = -1\\n symz = 1\\n self.wing_center_seg_point[:, i, 0] = (\\n self.wing_center_seg_point[:, i - 1, 0] * symx\\n )\\n self.wing_center_seg_point[:, i, 1] = (\\n self.wing_center_seg_point[:, i - 1, 1] * symy\\n )\\n self.wing_center_seg_point[:, i, 2] = (\\n self.wing_center_seg_point[:, i - 1, 2] * symz\\n )\\n c = True\\n a += 1\\n\\n self.w_seg_sec = seg_sec\\n\\n self.wing_area = round(self.wing_plt_area_main, 3)\\n\\n log.info(\\\"---------------------------------------------\\\")\\n log.info(\\\"--------------- Wing Results ----------------\\\")\\n log.info(f\\\"Number of Wings [-]: {self.wing_nb}\\\")\\n log.info(f\\\"Wing symmetry plane [-]: {self.wing_sym}\\\")\\n log.info(f\\\"Number of wing sections (not counting symmetry) [-]: {self.wing_sec_nb}\\\")\\n log.info(f\\\"Number of wing segments (not counting symmetry) [-]: {self.wing_seg_nb}\\\")\\n log.info(f\\\"Wing Span [m]: {self.wing_span}\\\")\\n log.info(f\\\"Wing MAC length [m]: {self.wing_mac[0,]}\\\")\\n log.info(f\\\"Wing max chord length [m]: {self.wing_max_chord}\\\")\\n log.info(f\\\"Wing min chord length [m]: {self.wing_min_chord}\\\")\\n log.info(f\\\"Main wing plantform area [m^2]: {self.wing_plt_area_main}\\\")\\n log.info(f\\\"Wings plantform area [m^2]: {self.wing_plt_area}\\\")\\n log.info(f\\\"Volume of each wing [m^3]: {self.wing_vol}\\\")\\n log.info(f\\\"Total wing volume [m^3]: {self.wing_tot_vol}\\\")\\n log.info(f\\\"Wing volume for fuel storage [m^3]: {self.wing_fuel_vol}\\\")\\n log.info(\\\"---------------------------------------------\\\")\",\n \"def get_wo_mthly_smry(self, workorder_browse):\\n wo_summary_data = []\\n wo_check_dict = {}\\n no = 0\\n if workorder_browse:\\n for work_rec in workorder_browse:\\n if work_rec.state and work_rec.state == \\\"done\\\":\\n no += 1\\n identification = \\\"\\\"\\n repair_line_data = \\\"\\\"\\n if work_rec.vehicle_id:\\n identification += work_rec.vehicle_id.name\\n if work_rec.vehicle_id.f_brand_id:\\n identification += \\\" \\\" + work_rec.vehicle_id.f_brand_id.name\\n if work_rec.vehicle_id.model_id:\\n identification += \\\" \\\" + work_rec.vehicle_id.model_id.name\\n for repaire_line in work_rec.repair_line_ids:\\n if repaire_line.complete is True:\\n if (\\n repaire_line.repair_type_id\\n and repaire_line.repair_type_id.name\\n ):\\n repair_line_data += (\\n repaire_line.repair_type_id.name + \\\", \\\"\\n )\\n if work_rec.parts_ids:\\n for parts_line in work_rec.parts_ids:\\n if work_rec.id in wo_check_dict.keys():\\n parts_data = {\\n \\\"no\\\": -1,\\n \\\"location\\\": \\\"\\\",\\n \\\"type\\\": \\\"\\\",\\n \\\"wo\\\": \\\"\\\",\\n \\\"identification\\\": \\\"\\\",\\n \\\"vin\\\": \\\"\\\",\\n \\\"plate_no\\\": \\\"\\\",\\n \\\"work_performed\\\": \\\"\\\",\\n \\\"part\\\": parts_line.product_id\\n and parts_line.product_id.default_code\\n or \\\"\\\",\\n \\\"qty\\\": parts_line.qty or 0.0,\\n \\\"uom\\\": parts_line.product_uom\\n and parts_line.product_uom.name\\n or \\\"\\\",\\n }\\n wo_summary_data.append(parts_data)\\n else:\\n wo_check_dict[work_rec.id] = work_rec.id\\n parts_data = {\\n \\\"no\\\": no,\\n \\\"location\\\": work_rec.team_id\\n and work_rec.team_id.name\\n or \\\"\\\",\\n \\\"type\\\": work_rec.main_type or \\\"\\\",\\n \\\"wo\\\": work_rec.name or \\\"\\\",\\n \\\"identification\\\": identification or \\\"\\\",\\n \\\"vin\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.vin_sn\\n or \\\"\\\",\\n \\\"plate_no\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.license_plate\\n or \\\"\\\",\\n \\\"work_performed\\\": repair_line_data\\n and repair_line_data[:-2]\\n or \\\"\\\",\\n \\\"part\\\": parts_line.product_id\\n and parts_line.product_id.default_code\\n or \\\"\\\",\\n \\\"qty\\\": parts_line.qty or 0.0,\\n \\\"uom\\\": parts_line.product_uom\\n and parts_line.product_uom.name\\n or \\\"\\\",\\n }\\n wo_summary_data.append(parts_data)\\n else:\\n parts_data = {\\n \\\"no\\\": no,\\n \\\"location\\\": work_rec.team_id\\n and work_rec.team_id.name\\n or \\\"\\\",\\n \\\"type\\\": work_rec.main_type or \\\"\\\",\\n \\\"wo\\\": work_rec.name or \\\"\\\",\\n \\\"identification\\\": identification or \\\"\\\",\\n \\\"vin\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.vin_sn\\n or \\\"\\\",\\n \\\"plate_no\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.license_plate\\n or \\\"\\\",\\n \\\"work_performed\\\": repair_line_data\\n and repair_line_data[:-2]\\n or \\\"\\\",\\n \\\"vehicle_make\\\": \\\"\\\",\\n \\\"qty\\\": \\\"\\\",\\n \\\"uom\\\": \\\"\\\",\\n }\\n wo_summary_data.append(parts_data)\\n if not wo_summary_data:\\n msg = _(\\n \\\"Warning! \\\\n\\\\\\n No data Available for selected work order.\\\"\\n )\\n raise UserError(msg)\\n return wo_summary_data\",\n \"def analyzeWeights(self, occludedPortions):\\r\\n\\t\\treturn None\",\n \"def update(self):\\n self.wc.update()\",\n \"def original_wcs(self):\\n return self._owcs\",\n \"def lookup(doc, wv):\\n checked = []\\n for word in doc:\\n try:\\n word in wv\\n except KeyError:\\n log.warning(\\\"Word not in model: %s\\\", word)\\n continue\\n checked.append(wv[word])\\n vec = np.mean(checked, axis=0)\\n return vec\",\n \"def give_wv_units(wave):\\n if not hasattr(wave, 'unit'):\\n uwave = u.Quantity(wave, unit=u.AA)\\n elif wave.unit is None:\\n uwave = u.Quantity(wave, unit=u.AA)\\n else:\\n uwave = u.Quantity(wave)\\n\\n return uwave\",\n \"def get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode):\\r\\n cnt_list=[]\\r\\n for b, g_wo1 in enumerate(g_wo):\\r\\n g_wc1 = g_wc[b]\\r\\n pr_wc1 = pr_wc[b]\\r\\n pr_wo1 = pr_wo[b]\\r\\n pr_wn1 = len(pr_wo1)\\r\\n g_wn1 = g_wn[b]\\r\\n\\r\\n if g_wn1 != pr_wn1:\\r\\n cnt_list.append(0)\\r\\n continue\\r\\n else:\\r\\n # Sort based wc sequence.\\r\\n if mode == 'test':\\r\\n idx = argsort(array(g_wc1))\\r\\n\\r\\n g_wo1_s = array(g_wo1)[idx]\\r\\n g_wo1_s = list(g_wo1_s)\\r\\n elif mode == 'train':\\r\\n # due to tearch forcing, no need to sort.\\r\\n g_wo1_s = g_wo1\\r\\n else:\\r\\n raise ValueError\\r\\n\\r\\n if type(pr_wo1) != list:\\r\\n raise TypeError\\r\\n if g_wo1_s == pr_wo1:\\r\\n cnt_list.append(1)\\r\\n else:\\r\\n cnt_list.append(0)\\r\\n return cnt_list\",\n \"def wrez2xml(self,newdoc,newroot):\\n\\t\\twrez = newdoc.createElement('wrez')\\n\\t\\twrez.setAttribute('hasChanged', str(self.hasChanged))\\n\\t\\tnewroot.appendChild(wrez)\\n\\n\\t\\tpath = newdoc.createElement('path')\\n\\t\\tpath.setAttribute('value', self.path)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('init_str')\\n\\t\\tpath.setAttribute('value', self.init_str)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('hash_sha512')\\n\\t\\tpath.setAttribute('value', self.hash_sha512)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('src_rip')\\n\\t\\tpath.setAttribute('value', self.src_rip)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('quality')\\n\\t\\tpath.setAttribute('value', self.quality)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('codec')\\n\\t\\tpath.setAttribute('value', self.codec)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('language')\\n\\t\\tpath.setAttribute('value', self.language)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('audio')\\n\\t\\tpath.setAttribute('value', self.audio)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('encoder')\\n\\t\\tpath.setAttribute('value', self.encoder)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('version')\\n\\t\\tpath.setAttribute('value', self.version)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('extension')\\n\\t\\tpath.setAttribute('value', self.extension)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('release_year')\\n\\t\\tpath.setAttribute('value', self.release_year)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('title')\\n\\t\\tpath.setAttribute('value', self.title)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('size')\\n\\t\\tpath.setAttribute('value', str(self.size))\\n\\t\\twrez.appendChild(path)\\n\\t\\treturn wrez\",\n \"def test_mlpi_cwro(self):\\r\\n\\t\\twith open(\\\"test_mlpi_cwro.txt\\\", \\\"w\\\") as test_mlpi_cwro_output:\\r\\n\\t\\t\\tsys.stdout = test_mlpi_cwro_output\\r\\n\\t\\t\\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=100, censor_words_one_pass=True)\\r\\n\\t\\twith open(\\\"test_mlpi_cwro.txt\\\", \\\"r\\\") as test_mlpi_cwro_output:\\r\\n\\t\\t\\twhile True:\\r\\n\\t\\t\\t\\tline_output = test_mlpi_cwro_output.readline()\\r\\n\\t\\t\\t\\tline_correct = cc_test_prose.readline()\\r\\n\\t\\t\\t\\tself.assertEqual(line_output, line_correct)\\r\\n\\t\\t\\t\\tif line_correct == '':\\r\\n\\t\\t\\t\\t\\tbreak\\r\\n\\t\\tcc_test_prose.seek(0)\\r\\n\\t\\tsys.stdout = sys.__stdout__\\r\\n\\t\\tos.remove(\\\"test_mlpi_cwro.txt\\\")\",\n \"def onReload(self, event):\\n\\n\\t\\tself.wv.Reload()\",\n \"def primalrepair(self,wlc,wuc,wlx,wux): # 3\\n if wlc is None:\\n wlc_ = None\\n else:\\n try:\\n wlc_ = memoryview(wlc)\\n except TypeError:\\n try:\\n _tmparr_wlc = array.array(\\\"d\\\",wlc)\\n except TypeError:\\n raise TypeError(\\\"Argument wlc has wrong type\\\")\\n else:\\n wlc_ = memoryview(_tmparr_wlc)\\n \\n else:\\n if wlc_.format != \\\"d\\\":\\n wlc_ = memoryview(array.array(\\\"d\\\",wlc))\\n \\n if wlc_ is not None and len(wlc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wlc has wrong length\\\")\\n if wuc is None:\\n wuc_ = None\\n else:\\n try:\\n wuc_ = memoryview(wuc)\\n except TypeError:\\n try:\\n _tmparr_wuc = array.array(\\\"d\\\",wuc)\\n except TypeError:\\n raise TypeError(\\\"Argument wuc has wrong type\\\")\\n else:\\n wuc_ = memoryview(_tmparr_wuc)\\n \\n else:\\n if wuc_.format != \\\"d\\\":\\n wuc_ = memoryview(array.array(\\\"d\\\",wuc))\\n \\n if wuc_ is not None and len(wuc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wuc has wrong length\\\")\\n if wlx is None:\\n wlx_ = None\\n else:\\n try:\\n wlx_ = memoryview(wlx)\\n except TypeError:\\n try:\\n _tmparr_wlx = array.array(\\\"d\\\",wlx)\\n except TypeError:\\n raise TypeError(\\\"Argument wlx has wrong type\\\")\\n else:\\n wlx_ = memoryview(_tmparr_wlx)\\n \\n else:\\n if wlx_.format != \\\"d\\\":\\n wlx_ = memoryview(array.array(\\\"d\\\",wlx))\\n \\n if wlx_ is not None and len(wlx_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wlx has wrong length\\\")\\n if wux is None:\\n wux_ = None\\n else:\\n try:\\n wux_ = memoryview(wux)\\n except TypeError:\\n try:\\n _tmparr_wux = array.array(\\\"d\\\",wux)\\n except TypeError:\\n raise TypeError(\\\"Argument wux has wrong type\\\")\\n else:\\n wux_ = memoryview(_tmparr_wux)\\n \\n else:\\n if wux_.format != \\\"d\\\":\\n wux_ = memoryview(array.array(\\\"d\\\",wux))\\n \\n if wux_ is not None and len(wux_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wux has wrong length\\\")\\n res = self.__obj.primalrepair(wlc_,wuc_,wlx_,wux_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def primalrepair(self,wlc_,wuc_,wlx_,wux_):\\n _wlc_minlength = self.getnumcon()\\n if self.getnumcon() > 0 and wlc_ is not None and len(wlc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wlc is not long enough: Is %d, expected %d\\\" % (len(wlc_),self.getnumcon()))\\n if isinstance(wlc_, numpy.ndarray) and wlc_.dtype is numpy.dtype(numpy.float64) and wlc_.flags.contiguous:\\n _wlc_copyarray = False\\n _wlc_tmp = ctypes.cast(wlc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wlc_ is not None:\\n _wlc_copyarray = True\\n _wlc_np_tmp = numpy.zeros(len(wlc_),numpy.dtype(numpy.float64))\\n _wlc_np_tmp[:] = wlc_\\n assert _wlc_np_tmp.flags.contiguous\\n _wlc_tmp = ctypes.cast(_wlc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wlc_copyarray = False\\n _wlc_tmp = None\\n \\n _wuc_minlength = self.getnumcon()\\n if self.getnumcon() > 0 and wuc_ is not None and len(wuc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wuc is not long enough: Is %d, expected %d\\\" % (len(wuc_),self.getnumcon()))\\n if isinstance(wuc_, numpy.ndarray) and wuc_.dtype is numpy.dtype(numpy.float64) and wuc_.flags.contiguous:\\n _wuc_copyarray = False\\n _wuc_tmp = ctypes.cast(wuc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wuc_ is not None:\\n _wuc_copyarray = True\\n _wuc_np_tmp = numpy.zeros(len(wuc_),numpy.dtype(numpy.float64))\\n _wuc_np_tmp[:] = wuc_\\n assert _wuc_np_tmp.flags.contiguous\\n _wuc_tmp = ctypes.cast(_wuc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wuc_copyarray = False\\n _wuc_tmp = None\\n \\n _wlx_minlength = self.getnumvar()\\n if self.getnumvar() > 0 and wlx_ is not None and len(wlx_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wlx is not long enough: Is %d, expected %d\\\" % (len(wlx_),self.getnumvar()))\\n if isinstance(wlx_, numpy.ndarray) and wlx_.dtype is numpy.dtype(numpy.float64) and wlx_.flags.contiguous:\\n _wlx_copyarray = False\\n _wlx_tmp = ctypes.cast(wlx_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wlx_ is not None:\\n _wlx_copyarray = True\\n _wlx_np_tmp = numpy.zeros(len(wlx_),numpy.dtype(numpy.float64))\\n _wlx_np_tmp[:] = wlx_\\n assert _wlx_np_tmp.flags.contiguous\\n _wlx_tmp = ctypes.cast(_wlx_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wlx_copyarray = False\\n _wlx_tmp = None\\n \\n _wux_minlength = self.getnumvar()\\n if self.getnumvar() > 0 and wux_ is not None and len(wux_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wux is not long enough: Is %d, expected %d\\\" % (len(wux_),self.getnumvar()))\\n if isinstance(wux_, numpy.ndarray) and wux_.dtype is numpy.dtype(numpy.float64) and wux_.flags.contiguous:\\n _wux_copyarray = False\\n _wux_tmp = ctypes.cast(wux_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wux_ is not None:\\n _wux_copyarray = True\\n _wux_np_tmp = numpy.zeros(len(wux_),numpy.dtype(numpy.float64))\\n _wux_np_tmp[:] = wux_\\n assert _wux_np_tmp.flags.contiguous\\n _wux_tmp = ctypes.cast(_wux_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wux_copyarray = False\\n _wux_tmp = None\\n \\n res = __library__.MSK_XX_primalrepair(self.__nativep,_wlc_tmp,_wuc_tmp,_wlx_tmp,_wux_tmp)\\n if res != 0:\\n _,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def vp():\\r\\n section = document.add_section()\\r\\n new_width, new_height = section.page_height, section.page_width\\r\\n section.orientation = WD_ORIENT.LANDSCAPE\\r\\n section.page_width = 10058400\\r\\n section.page_height = 7772400\\r\\n document.add_heading('Virtual Proxy details', 1)\\r\\n virtualproxy_metrics= ['description', 'prefix', 'authenticationModuleRedirectUri', 'sessionModuleBaseUri', 'loadBalancingModuleBaseUri', 'authenticationMethod', 'headerAuthenticationMode',\\r\\n 'headerAuthenticationHeaderName', 'headerAuthenticationStaticUserDirectory', 'headerAuthenticationDynamicUserDirectory', 'anonymousAccessMode', 'windowsAuthenticationEnabledDevicePattern',\\r\\n 'sessionCookieHeaderName', 'sessionCookieDomain', 'additionalResponseHeaders', 'sessionInactivityTimeout', 'extendedSecurityEnvironment', 'websocketCrossOriginWhiteList', 'defaultVirtualProxy',\\r\\n 'tags','samlMetadataIdP', 'samlHostUri', 'samlEntityId', 'samlAttributeUserId', 'samlAttributeUserDirectory', 'samlAttributeSigningAlgorithm', 'samlAttributeMap', 'magicLinkHostUri',\\r\\n 'magicLinkFriendlyName','jwtPublicKeyCertificate','jwtAttributeUserDirectory','jwtAttributeMap','jwtAttributeUserId']\\r\\n \\r\\n virtualproxynodes = get_qlik_sense.get_virtualproxy()\\r\\n num_of_virtualproxys = len(virtualproxynodes)\\r\\n num_of_virtualproxy_metrics = len(virtualproxy_metrics)\\r\\n table = document.add_table(rows=num_of_virtualproxy_metrics+1, cols=num_of_virtualproxys+1)\\r\\n table.style = 'Grid Table 1 Light Accent 1'\\r\\n row = table.rows[0]\\r\\n row.cells[0].text = 'Metric'\\r\\n for item in range(0, num_of_virtualproxys):\\r\\n row.cells[item+1].text = virtualproxynodes[item][29]\\r\\n for item in range(num_of_virtualproxy_metrics):\\r\\n row = table.rows[item+1]\\r\\n row.cells[0].text = str(virtualproxy_metrics[item])\\r\\n for virtualproxynode in range(num_of_virtualproxys):\\r\\n row.cells[virtualproxynode+1].text = str(virtualproxynodes[virtualproxynode][item])\\r\\n\\r\\n document.add_page_break()\",\n \"def get_bforce_wm_ws_Gx_surf(self):\\n\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w'] \\n \\n self.Gm1 = np.zeros([Ly])\\n self.dGm1_dS = np.zeros([Ly]) \\n self.Gt1 = np.zeros([Ly])\\n self.dGt1_dS = np.zeros([Ly]) \\n self.Bfsfc_bl = np.zeros([Ly])\\n self.Av_bl = np.zeros([Ly])\\n self.dAv_bl = np.zeros([Ly])\\n \\n #debugging\\n self.wm_surf = np.zeros([Ly])\\n self.ws_surf = np.zeros([Ly]) \\n\\n #---> j-loop\\n for j in range(Ly): \\n k_w = self.kbl[j] # KBL is \\\"new bl index after calling find_new_kbl()\\n z_bl = z_u_w[j,N] - self.hbls[j]\\n zscale = self.hbls[j] \\n \\n if self.swr_frac[j,k_w-1] > 0:\\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\\n \\n else:\\n Bfsfc = self.Bo[j] + self.Bosol[j]\\n \\n # CALCUALTE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm_surf[j] = wm\\n self.ws_surf[j] = ws \\n\\n if self.LIMIT_UNSTABLE_ONLY:\\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\\n else:\\n f1 = 0\\n\\n \\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n\\n #MOMENTUM \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl[j] = Av_bl\\n self.dAv_bl[j] = dAv_bl\\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \\n\\n #TEMPERATURE(BUOYANCY)\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \\n\\n self.Bfsfc_bl[j] = Bfsfc\",\n \"def get_w(self):\\n raise NotImplementedError\",\n \"def propose(self):\\n\\n\\n fb = 0.0\\n changed_any = False\\n\\n while not changed_any:\\n new = copy(self) ## Now we just copy the whole thing\\n\\n for w in self.all_words():\\n if flip(self.propose_p):\\n try:\\n xp, xfb = self.get_word(w).propose()\\n\\n changed_any = True\\n new.set_word(w, xp)\\n fb += xfb\\n\\n except ProposalFailedException:\\n pass\\n\\n\\n return new, fb\",\n \"def build_W(points):\\n return None\",\n \"def computeW(self):\\n E = np.where(self.v > 0, 1, -1)\\n # theshold the connections to only -1,1\\n binary_weights = np.where(self.c > 0, 1, self.c)\\n binary_weights = np.where(binary_weights < 0, -1, binary_weights)\\n W = np.sum(binary_weights * np.dot(E.reshape(-1,1), E.reshape(1,-1))) # W = C * E * E\\n self.W = W\\n if np.sum(binary_weights) != 0:\\n self.W = self.W / np.sum(binary_weights) # W / W*\\n return self.W\",\n \"def vcac_worklfow_request(self):\\n logging.info(\\\"Inside ucsvm_worklfow_request method base class\\\")\\n return None\",\n \"def get_wordcloud():\\n params = request.args\\n result = None\\n\\n def set_result(x):\\n nonlocal result # This is ugly, ew, gotta fix this\\n result = x\\n\\n pipeline_zoo.get_full_word_distribution(set_result).feed_data((params, None))\\n return jsonify({\\n 'word_distribution': result\\n })\",\n \"def get_vector(word, model):\\n return model.wv[word]\",\n \"def new_words_only(base_words, window_words):\\n new_words = []\\n if base_words:\\n for wword in window_words:\\n dont_include = False\\n for bword in base_words:\\n if CharNetRunner._do_words_intersect(wword, bword):\\n dont_include = True\\n break\\n if not dont_include:\\n new_words.append(wword)\\n else:\\n new_words = window_words\\n\\n return new_words\",\n \"def search_clues(self):\\r\\n print(\\\"\\\\n************Searching Clues************\\\\n\\\")\\r\\n for word_id in self.words.keys():\\r\\n if not self.words[word_id].see and not self.words[word_id].wth:\\r\\n clue = pop_backslash(self.words[word_id].clue)\\r\\n temp = word_domain(\\\"allintext:\\\" + clue +' -crossword',self.words[word_id].length)\\r\\n temp2 = temp + word_domain(clue +' -crossword',self.words[word_id].length)\\r\\n domain = temp2 + data_muse(clue, self.words[word_id].length)\\r\\n unique_list = []\\r\\n for x in domain: \\r\\n y = x.upper()\\r\\n # check if exists in unique_list or not \\r\\n if y not in unique_list: \\r\\n unique_list.append(y) \\r\\n \\r\\n self.words[word_id].assign_word_domain(unique_list)\\r\\n print(\\\"\\\\nSearch is done...\\\")\",\n \"def build_parameters(pobj):\\n ViscosityWilke.build_parameters(pobj)\",\n \"def wps(model, data):\\n with msg.loading(f\\\"Loading model '{model}'...\\\"):\\n nlp = spacy.load(model)\\n texts = (eg[\\\"text\\\"] for eg in srsly.read_jsonl(data))\\n n_docs = 0\\n n_words = 0\\n start_time = timer()\\n for doc in nlp.pipe(texts):\\n n_docs += 1\\n n_words += len(doc)\\n end_time = timer()\\n wps = int(n_words / (end_time - start_time))\\n result = [\\n (\\\"Docs\\\", f\\\"{n_docs:,}\\\"),\\n (\\\"Words\\\", f\\\"{n_words:,}\\\"),\\n (\\\"Words/s\\\", f\\\"{wps:,}\\\"),\\n ]\\n msg.table(result, widths=(7, 12), aligns=(\\\"l\\\", \\\"r\\\"))\",\n \"def isMWS_WD(primary=None, gaia=None, galb=None, astrometricexcessnoise=None,\\n pmra=None, pmdec=None, parallax=None, parallaxovererror=None,\\n photbprpexcessfactor=None, astrometricsigma5dmax=None,\\n gaiagmag=None, gaiabmag=None, gaiarmag=None, paramssolved=None):\\n if primary is None:\\n primary = np.ones_like(gaia, dtype='?')\\n mws = primary.copy()\\n\\n # ADM do not target any objects for which entries are NaN\\n # ADM and turn off the NaNs for those entries.\\n if photbprpexcessfactor is not None:\\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\\n np.isnan(parallax) | np.isnan(photbprpexcessfactor))\\n else:\\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\\n np.isnan(parallax))\\n w = np.where(nans)[0]\\n if len(w) > 0:\\n parallax, gaiagmag = parallax.copy(), gaiagmag.copy()\\n gaiabmag, gaiarmag = gaiabmag.copy(), gaiarmag.copy()\\n if photbprpexcessfactor is not None:\\n photbprpexcessfactor = photbprpexcessfactor.copy()\\n # ADM safe to make these zero regardless of cuts as...\\n photbprpexcessfactor[w] = 0.\\n parallax[w] = 0.\\n gaiagmag[w], gaiabmag[w], gaiarmag[w] = 0., 0., 0.\\n # ADM ...we'll turn off all bits here.\\n mws &= ~nans\\n# log.info('{}/{} NaNs in file...t = {:.1f}s'\\n# .format(len(w), len(mws), time()-start))\\n\\n # ADM apply the selection for all MWS-WD targets\\n # ADM must be a Legacy Surveys object that matches a Gaia source\\n mws &= gaia\\n\\n # ADM and all astrometric parameters are measured.\\n mws &= paramssolved == 31\\n\\n # ADM Gaia G mag of less than 20\\n mws &= gaiagmag < 20.\\n\\n # ADM Galactic b at least 20o from the plane\\n mws &= np.abs(galb) > 20.\\n\\n # ADM gentle cut on parallax significance\\n mws &= parallaxovererror > 1.\\n\\n # ADM Color/absolute magnitude cuts of (defining the WD cooling sequence):\\n # ADM Gabs > 5\\n # ADM Gabs > 5.93 + 5.047(Bp-Rp)\\n # ADM Gabs > 6(Bp-Rp)3 - 21.77(Bp-Rp)2 + 27.91(Bp-Rp) + 0.897\\n # ADM Bp-Rp < 1.7\\n Gabs = gaiagmag+5.*np.log10(parallax.clip(1e-16))-10.\\n br = gaiabmag - gaiarmag\\n mws &= Gabs > 5.\\n mws &= Gabs > 5.93 + 5.047*br\\n mws &= Gabs > 6*br*br*br - 21.77*br*br + 27.91*br + 0.897\\n mws &= br < 1.7\\n\\n # ADM Finite proper motion to reject quasars\\n # ADM Inexplicably I'm getting a Runtimewarning here for\\n # ADM a few values in the sqrt, so I'm catching it\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n pm = np.sqrt(pmra**2. + pmdec**2.)\\n mws &= pm > 2.\\n\\n # ADM As of DR7, photbprpexcessfactor and astrometricsigma5dmax are not in the\\n # ADM imaging catalogs. Until they are, ignore these cuts\\n if photbprpexcessfactor is not None:\\n # ADM remove problem objects, which often have bad astrometry\\n mws &= photbprpexcessfactor < 1.7 + 0.06*br*br\\n\\n if astrometricsigma5dmax is not None:\\n # ADM Reject white dwarfs that have really poor astrometry while\\n # ADM retaining white dwarfs that only have relatively poor astrometry\\n mws &= ((astrometricsigma5dmax < 1.5) |\\n ((astrometricexcessnoise < 1.) & (parallaxovererror > 4.) & (pm > 10.)))\\n\\n return mws\",\n \"def get_doc_prov(j, gcis_url, refList):\\n gcis_ns = \\\"https://gcis-search-stage.jpl.net:3000/gcis.owl#\\\"\\n doc = ProvEsDocument()\\n bndl = None\\n \\n#to get people attributed to, you need to grab article -> jornal_identifier -> look up in references\\n# for ref in refList:\\n# if ref['child_publication'] == j['uri']:\\n \\n\\n\\n doc_attrs = [\\n (\\\"prov:type\\\", 'gcis:Article'),\\n (\\\"prov:label\\\", j['title']),\\n (\\\"prov:location\\\", j['uri']),\\n #(\\\"prov:wasAttributedTo\\\", j['']),\\n ]\\n doc.entity('bibo:%s' % j['identifier'], doc_attrs)\\n\\n prov_json = json.loads(doc.serialize())\\n\\n return prov_json\",\n \"def test_visualize_wfe_budget():\\n nrc = webbpsf.NIRCam()\\n nrc.visualize_wfe_budget()\",\n \"def evaluate_design(self): # to update the pr object\",\n \"def getVWFile(tsvFile, vwFile, dataIndex, dictionary, tfidf_model, train=True):\\r\\n start = datetime.now()\\r\\n \\r\\n # extract all the index\\r\\n catIndex = dataIndex[\\\"catIndex\\\"]\\r\\n subCatIndex = dataIndex[\\\"subCatIndex\\\"]\\r\\n attrsKeyIndex = dataIndex[\\\"attrsKeyIndex\\\"]\\r\\n attrsValIndex = dataIndex[\\\"attrsValIndex\\\"]\\r\\n wordIndex = dataIndex[\\\"wordIndex\\\"]\\r\\n \\r\\n with open(vwFile, \\\"wb\\\") as vwWriter:\\r\\n with open(tsvFile, \\\"rb\\\") as tsvReader:\\r\\n itemReader = DictReader(tsvReader, delimiter='\\\\t', quotechar='\\\"')\\r\\n for i, item in enumerate(itemReader):\\r\\n item = {featureName:featureValue.decode('utf-8') \\\\\\r\\n for featureName,featureValue in item.items() \\\\\\r\\n if featureValue is not None}\\r\\n\\r\\n # get header\\r\\n itemid = int(item[\\\"itemid\\\"])\\r\\n label = int(item[\\\"is_blocked\\\"]) if train else 1\\r\\n header = \\\"%s '%s \\\" % (int(2*label - 1), itemid)\\r\\n \\r\\n # category\\r\\n categoryFeat = \\\"|C %s \\\" % catIndex[ item[\\\"category\\\"] ]\\r\\n \\r\\n # subcategory\\r\\n subcategoryFeat = \\\"|SC %s \\\" % subCatIndex[ item[\\\"subcategory\\\"] ]\\r\\n \\r\\n # title\\r\\n title = [ str(wordIndex[w]) for w in getWords(item[\\\"title\\\"]) ]\\r\\n # first-gram\\r\\n title_start = title[0] if len(title)>0 else \\\"0\\\"\\r\\n # end-gram\\r\\n title_end = title[-1] if len(title)>0 else \\\"0\\\"\\r\\n # naming is a pain for me\\r\\n titleFeat = \\\"|T %s |bT %s |cT %s \\\" % (\\\" \\\".join(title), title_start, title_end)\\r\\n titleStatsFeat = \\\"|t %s \\\" % getTextStatsFeat(item[\\\"title\\\"])\\r\\n \\r\\n # description\\r\\n description = [ str(wordIndex[w]) for w in getWords(item[\\\"description\\\"]) ]\\r\\n # first-gram\\r\\n description_start = description[0] if len(description)>0 else \\\"0\\\"\\r\\n # end-gram\\r\\n description_end = description[-1] if len(description)>0 else \\\"0\\\"\\r\\n descriptionFeat = \\\"|D %s |fD %s |gD %s \\\" % (\\\" \\\".join(description), description_start, description_end)\\r\\n descriptionStatsFeat = \\\"|d %s \\\" % getTextStatsFeat(item[\\\"description\\\"])\\r\\n tfidf_feat1 = getTfidfFeat(getUnigram(description), dictionary[1], tfidf_model[1])\\r\\n # 2gram tfidf seem to harm the performance, you are save to drop it here\\r\\n tfidf_feat2 = getTfidfFeat(getBigram(description, \\\"_\\\"), dictionary[2], tfidf_model[2])\\r\\n descriptionFeat += \\\"|iD %s |jD %s \\\" % (tfidf_feat1, tfidf_feat2)\\r\\n \\r\\n # attrs\\r\\n attrsFeat = \\\"\\\"\\r\\n countAttrs = 0\\r\\n if \\\"attrs\\\" in item:\\r\\n attrsDict = getAttrsDict(item[\\\"attrs\\\"])\\r\\n #print attrs\\r\\n for k,v in list(attrsDict.items()):\\r\\n countAttrs += 1\\r\\n attrsFeat += \\\"|A%s %s \\\" % (attrsKeyIndex[k], attrsValIndex[v])\\r\\n attrsFeat += \\\"|a \\\"\\r\\n for k,v in list(attrsDict.items()):\\r\\n attrsFeat += \\\"%s \\\" % (attrsKeyIndex[k]) \\r\\n if len(attrsFeat) == 0:\\r\\n attrsFeat = \\\"|NA 1 \\\"\\r\\n attrsFeat += \\\"|hAC %s \\\" % countAttrs\\r\\n \\r\\n # price\\r\\n priceFeat = \\\"|P %s \\\" % item[\\\"price\\\"] \\r\\n # phones_cnt\\r\\n phonesCntFeat = \\\"|p %s \\\" % item[\\\"phones_cnt\\\"]\\r\\n # emails_cnt\\r\\n emailsCntFeat = \\\"|e %s \\\" % item[\\\"emails_cnt\\\"]\\r\\n # urls_cnt\\r\\n urlsCntFeat = \\\"|u %s \\\" % item[\\\"urls_cnt\\\"]\\r\\n \\r\\n # output\\r\\n vwLine = header \\\\\\r\\n + categoryFeat \\\\\\r\\n + subcategoryFeat \\\\\\r\\n + titleFeat \\\\\\r\\n + titleStatsFeat \\\\\\r\\n + descriptionFeat \\\\\\r\\n + descriptionStatsFeat \\\\\\r\\n + attrsFeat \\\\\\r\\n + priceFeat \\\\\\r\\n + phonesCntFeat \\\\\\r\\n + emailsCntFeat \\\\\\r\\n + urlsCntFeat[:-1] + \\\"\\\\n\\\"\\r\\n vwWriter.write( vwLine )\\r\\n \\r\\n # report progress\\r\\n if (i+1)%10000 == 0:\\r\\n print(( \\\"\\\\n%s\\\\t%s\\\"%((i+1),str(datetime.now() - start)) ))\\r\\n print(( \\\"Sample output:\\\\n%s\\\" % vwLine ))\",\n \"def check_wf(self,wf):\\n pass\",\n \"def geocube():\",\n \"def has_wcs(self):\\n return self.wcs is not None\",\n \"def plotrgcloud(self):\\n print self.kpunten\\n for i in range(len(self.kpunten[0])):\\n self.writetext('sen ='+ self.kpunten[0][i][0], (0.65,0.85), axnum = 0, hor = None ,ver = None , rot = None ,fs =14 , transform = self.fig.axes[0].transAxes)\\n if i == len(self.kpunten[0]) -1 :\\n end = None\\n else:\\n end = self.kpunten[0][i+1][1] + 1\\n print end\\n self.plotrgwrap( self.rgindex,2*self.reader.npair+self.rgindex,'real part of rgvars (a.u)' , 'imaginary part of rgvars (a.u.)', tit ='RG vars g = %f all states'%(self.chardata) , begin = self.kpunten[0][i][1] , stop = end , name = 'cpcloud'+ self.kpunten[0][i][0] , filenum = 0)\",\n \"def newWS(self, y):\\n keys=np.array(self.ImageSolution.keys())\\n try:\\n i=abs(keys-y).argmin()\\n ws=self.ImageSolution[keys[i]]\\n nws=WavelengthSolution.WavelengthSolution(ws.x_arr,ws.w_arr, order=ws.order, function=ws.function)\\n nws.fit()\\n return nws\\n except :\\n return self.ws\",\n \"def calc_wvf(pedestrian, key, face, mesh_area,radius): \\n normal = envuo.py3dmodel.construct.make_vector((0,0,0),envuo.py3dmodel.calculate.face_normal(face))\\n surf2ped = envuo.py3dmodel.construct.make_vector(key,pedestrian)\\n sa_ped = 4.0*np.pi*radius**2\\n theta = normal.Angle(surf2ped)\\n h = surf2ped.Magnitude()/radius \\n phi = np.arctan(1/h)\\n threshold = np.pi/2.0 - phi\\n\\n if abs(h*np.cos(theta)) > 1:\\n F = abs(np.cos(theta))/h**2; \\n else:\\n x = np.sqrt(h**2-1)/np.tan(theta) #np.sqrt(h**2-1)\\n y = np.sqrt(1-x**2) #-x/np.tan(theta) #\\n F = (np.pi - abs(np.cos(x)) - x*y*np.tan(theta)**2)*abs(np.cos(theta))/(np.pi*h**2) + np.arctan(y*abs(np.cos(theta))/x)/np.pi; \\n print pedestrian,' passes threshold'\\n return mesh_area*F/sa_ped\",\n \"def compute_RS(W):\\n return None\",\n \"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',\\n verbose=False))\\n # No NaNs are supposed to be in the output.\\n self.assertEqual(np.isnan(wv).any(), False)\\n rms1 = rms(rec['wv_250_500_25'], wv[250:500:25])\\n rms2 = rms(rec['wv_750_1000_25'], wv[750:1000:25])\\n self.assertEqual(True, rms1 < 1e-6)\\n self.assertEqual(True, rms2 < 1e-6)\",\n \"def test_slpi_cwro(self):\\r\\n\\t\\twith open(\\\"test_slpi_cwro.txt\\\", \\\"w\\\") as test_slpi_cwro_output:\\r\\n\\t\\t\\tsys.stdout = test_slpi_cwro_output # Redirect print in censor to temporary output file\\r\\n\\t\\t\\t# Appropriate censor function call\\r\\n\\t\\t\\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=1, censor_words_one_pass=True)\\r\\n\\t\\twith open(\\\"test_slpi_cwro.txt\\\", \\\"r\\\") as test_slpi_cwro_output:\\r\\n\\t\\t\\twhile True:\\r\\n\\t\\t\\t\\t# Assert every output line in file matches the expected output\\r\\n\\t\\t\\t\\tline_output = test_slpi_cwro_output.readline()\\r\\n\\t\\t\\t\\tline_correct = cc_test_prose.readline()\\r\\n\\t\\t\\t\\tself.assertEqual(line_output, line_correct)\\r\\n\\t\\t\\t\\tif line_correct == '': # Stop reading expected output at eof\\r\\n\\t\\t\\t\\t\\tbreak\\r\\n\\t\\tcc_test_prose.seek(0) # Reset read head in expected output file\\r\\n\\t\\tsys.stdout = sys.__stdout__ # Reset stdout redirection\\r\\n\\t\\tos.remove(\\\"test_slpi_cwro.txt\\\") # Delete temporary output file if test is successful\\r\",\n \"def _vSWVT(self):\\r\\n\\r\\n logStr = \\\"{0:s}.{1:s}: \\\".format(self.__class__.__name__, sys._getframe().f_code.co_name)\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'Start.')) \\r\\n \\r\\n try: \\r\\n vSWVT = None\\r\\n vSWVT=pd.merge(self.dataFrames['SWVT'],self.dataFrames['SWVT_ROWT'],left_on='pk',right_on='fk')\\r\\n vSWVT['ZEIT']=pd.to_numeric(vSWVT['ZEIT']) \\r\\n vSWVT['W']=pd.to_numeric(vSWVT['W']) \\r\\n vSWVT['ZEIT_RANG']=vSWVT.groupby(['pk_x'])['ZEIT'].rank(ascending=True)\\r\\n #\\r\\n vSWVT_g=vSWVT.groupby(['pk_x'], as_index=False).agg({'W':[np.min,np.max]})\\r\\n vSWVT_g.columns= [tup[0]+tup[1] for tup in zip(vSWVT_g.columns.get_level_values(0),vSWVT_g.columns.get_level_values(1))]\\r\\n vSWVT_g.rename(columns={'Wamin':'W_min','Wamax':'W_max'},inplace=True)\\r\\n #\\r\\n vSWVT=pd.merge(vSWVT,vSWVT_g,left_on='pk_x',right_on='pk_x')\\r\\n #\\r\\n vSWVT=vSWVT[vSWVT['ZEIT_RANG']==1]\\r\\n #\\r\\n vSWVT=vSWVT[['NAME','BESCHREIBUNG','INTPOL','ZEITOPTION','W','W_min','W_max','pk_x']]\\r\\n #\\r\\n vSWVT.rename(columns={'pk_x':'pk'},inplace=True)\\r\\n \\r\\n except Exception as e:\\r\\n logStrFinal=\\\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\\\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\\r\\n logger.error(logStrFinal) \\r\\n raise XmError(logStrFinal) \\r\\n finally:\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'_Done.'))\\r\\n return vSWVT\",\n \"def collecte_docs(self, chercheur, overwrite=False): # self,\\n init = overwrite # If True, data persistence is lost when references are updated\\n docs = hal.find_publications(chercheur[\\\"halId_s\\\"], \\\"authIdHal_s\\\")\\n\\n progress_recorder = ProgressRecorder(self)\\n progress_recorder.set_progress(0, len(docs), description=\\\"récupération des données HAL\\\")\\n # Insert documents collection\\n for num, doc in enumerate(docs):\\n doc[\\\"country_colaboration\\\"] = location_docs.generate_countrys_fields(doc)\\n doc = doi_enrichissement.docs_enrichissement_doi(doc)\\n if \\\"fr_abstract_s\\\" in doc.keys():\\n if isinstance(doc[\\\"fr_abstract_s\\\"], list):\\n doc[\\\"fr_abstract_s\\\"] = \\\"/n\\\".join(doc[\\\"fr_abstract_s\\\"])\\n if len(doc[\\\"fr_abstract_s\\\"]) > 100:\\n doc[\\\"fr_entites\\\"] = keyword_enrichissement.return_entities(\\n doc[\\\"fr_abstract_s\\\"], \\\"fr\\\"\\n )\\n doc[\\\"fr_teeft_keywords\\\"] = keyword_enrichissement.keyword_from_teeft(\\n doc[\\\"fr_abstract_s\\\"], \\\"fr\\\"\\n )\\n if \\\"en_abstract_s\\\" in doc.keys():\\n if isinstance(doc[\\\"en_abstract_s\\\"], list):\\n doc[\\\"en_abstract_s\\\"] = \\\"/n\\\".join(doc[\\\"en_abstract_s\\\"])\\n if len(doc[\\\"en_abstract_s\\\"]) > 100:\\n doc[\\\"en_entites\\\"] = keyword_enrichissement.return_entities(\\n doc[\\\"en_abstract_s\\\"], \\\"en\\\"\\n )\\n doc[\\\"en_teeft_keywords\\\"] = keyword_enrichissement.keyword_from_teeft(\\n doc[\\\"en_abstract_s\\\"], \\\"en\\\"\\n )\\n\\n doc[\\\"_id\\\"] = doc[\\\"docid\\\"]\\n doc[\\\"validated\\\"] = True\\n\\n doc[\\\"harvested_from\\\"] = \\\"researcher\\\"\\n\\n doc[\\\"harvested_from_ids\\\"] = []\\n doc[\\\"harvested_from_label\\\"] = []\\n\\n #\\n #\\n # print(doc[\\\"authorship\\\"], doc ['authLastName_s'])\\n\\n if len(doc[\\\"authIdHal_s\\\"]) != len(doc[\\\"authLastName_s\\\"]):\\n # print (\\\"elastichal.py : test d'autorat no good\\\")\\n # test sur le nom complet...\\n nom = [\\n truc\\n for truc in doc[\\\"authLastName_s\\\"]\\n if chercheur[\\\"lastName\\\"].lower() in truc.lower()\\n ] # pour les récemment mariés qui auraient un nom composé...\\n # Après si 'lun des co-auteur porte le même nom...\\n if len(nom) > 0:\\n nom = nom[0].title()\\n try:\\n if doc[\\\"authLastName_s\\\"].index(nom) == 0: # premier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"firstAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n elif (\\n doc[\\\"authLastName_s\\\"].index(nom) == len(doc[\\\"authLastName_s\\\"]) - 1\\n ): # dernier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"lastAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n except ValueError:\\n doc[\\\"authorship\\\"] = []\\n else:\\n doc[\\\"authorship\\\"] = []\\n elif chercheur[\\\"halId_s\\\"] in doc[\\\"authIdHal_s\\\"]:\\n if doc[\\\"authIdHal_s\\\"].index(chercheur[\\\"halId_s\\\"]) == 0:\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"firstAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n elif (\\n doc[\\\"authIdHal_s\\\"].index(chercheur[\\\"halId_s\\\"]) == len(doc[\\\"authIdHal_s\\\"]) - 1\\n ): # dernier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"lastAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n else:\\n doc[\\\"authorship\\\"] = []\\n else:\\n doc[\\\"authorship\\\"] = []\\n\\n doc[\\\"harvested_from_ids\\\"].append(chercheur[\\\"halId_s\\\"])\\n\\n # historique d'appartenance du docId\\n # pour attribuer les bons docs aux chercheurs\\n # harvet_history.append({'docid': doc['docid'], 'from': row['halId_s']})\\n #\\n # for h in harvet_history:\\n # if h['docid'] == doc['docid']:\\n # if h['from'] not in doc[\\\"harvested_from_ids\\\"]:\\n # doc[\\\"harvested_from_ids\\\"].append(h['from'])\\n\\n doc[\\\"records\\\"] = []\\n\\n doc[\\\"MDS\\\"] = utils.calculate_mds(doc)\\n\\n try:\\n should_be_open = utils.should_be_open(doc)\\n if should_be_open == 1:\\n doc[\\\"should_be_open\\\"] = True\\n if should_be_open == -1:\\n doc[\\\"should_be_open\\\"] = False\\n\\n if should_be_open == 1 or should_be_open == 2:\\n doc[\\\"isOaExtra\\\"] = True\\n elif should_be_open == -1:\\n doc[\\\"isOaExtra\\\"] = False\\n except IndexError:\\n print(\\\"publicationDate_tdate error ?\\\")\\n doc[\\\"Created\\\"] = datetime.datetime.now().isoformat()\\n\\n if not init: # récupération de l'existant pour ne pas écraser\\n field = \\\"_id\\\"\\n doc_param = esActions.scope_p(field, doc[\\\"_id\\\"])\\n\\n if not es.indices.exists(\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\"\\n ): # -researchers\\\" + row[\\\"ldapId\\\"] + \\\"-documents\\n print(\\\"exception \\\", chercheur[\\\"labHalId\\\"], chercheur[\\\"ldapId\\\"])\\n\\n res = es.search(\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\",\\n body=doc_param,\\n ) # -researchers\\\" + row[\\\"ldapId\\\"] + \\\"-documents\\n\\n if len(res[\\\"hits\\\"][\\\"hits\\\"]) > 0:\\n doc[\\\"validated\\\"] = res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"validated\\\"]\\n if \\\"authorship\\\" in res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"]:\\n doc[\\\"authorship\\\"] = res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"authorship\\\"]\\n\\n if (\\n res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"modifiedDate_tdate\\\"]\\n != doc[\\\"modifiedDate_tdate\\\"]\\n ):\\n doc[\\\"records\\\"].append(\\n {\\n \\\"beforeModifiedDate_tdate\\\": doc[\\\"modifiedDate_tdate\\\"],\\n \\\"MDS\\\": res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"MDS\\\"],\\n }\\n )\\n\\n else:\\n doc[\\\"validated\\\"] = True\\n progress_recorder.set_progress(num, len(docs), description=\\\"(récolte)\\\")\\n progress_recorder.set_progress(num, len(docs), description=\\\"(indexation)\\\")\\n helpers.bulk(\\n es,\\n docs,\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\",\\n refresh=\\\"wait_for\\\",\\n )\\n\\n return chercheur # au cas où\",\n \"def stop_word(w): # local feature\\n return (w in swl)\",\n \"def init_ngrams(self):\\n self.wv.ngrams = {}\\n all_ngrams = []\\n self.wv.syn0 = np.zeros((len(self.wv.vocab), self.vector_size), dtype=REAL)\\n\\n for w, vocab in self.wv.vocab.items():\\n all_ngrams += compute_ngrams(w, self.wv.min_n, self.wv.max_n)\\n self.wv.syn0[vocab.index] += np.array(self.wv.syn0_ngrams[vocab.index])\\n\\n all_ngrams = set(all_ngrams)\\n self.num_ngram_vectors = len(all_ngrams)\\n ngram_indices = []\\n for i, ngram in enumerate(all_ngrams):\\n ngram_hash = ft_hash(ngram)\\n ngram_indices.append(len(self.wv.vocab) + ngram_hash % self.bucket)\\n self.wv.ngrams[ngram] = i\\n self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)\\n\\n ngram_weights = self.wv.syn0_ngrams\\n\\n logger.info(\\n \\\"loading weights for %s words for fastText model from %s\\\",\\n len(self.wv.vocab), self.file_name\\n )\\n\\n for w, vocab in self.wv.vocab.items():\\n word_ngrams = compute_ngrams(w, self.wv.min_n, self.wv.max_n)\\n for word_ngram in word_ngrams:\\n self.wv.syn0[vocab.index] += np.array(ngram_weights[self.wv.ngrams[word_ngram]])\\n\\n self.wv.syn0[vocab.index] /= (len(word_ngrams) + 1)\\n logger.info(\\n \\\"loaded %s weight matrix for fastText model from %s\\\",\\n self.wv.syn0.shape, self.file_name\\n )\",\n \"def exposedSurf(self):\\n if self.precision:\\n h = self.evaluations.exposedWing.edges[1].point1.x # height of trapezoid\\n B = self.chordRootW # major base of trapezoid\\n b = self.evaluations.chordIntersected.edges[1].length # minor base of trapezoid\\n internalS = 2 * (0.5 * (b + B) * h) # wing surface internal at fuselage\\n return self.surfaceW - internalS\\n else:\\n return self.surfaceW - self.fuselageDiameter * self.cMACW # first guess for a faster evaluation\",\n \"def v(w,s):\\n return w\",\n \"def compare_wavs_length(c_wv, s_wv):\\n\\n # If the style wav is shorter than the content wav, exit in error\\n if s_wv.shape[0] < c_wv.shape[0]:\\n raise WavError(\\\"The style wav must be as long or longer than the content wav\\\")\\n\\n # If the style wav is longer, truncate it to match the content length\\n elif s_wv.shape[0] > c_wv.shape[0]:\\n print(\\\"Truncating style wav to match content wav length\\\")\\n s_wv = np.copy(s_wv[:c_wv.shape[0],:])\\n\\n return s_wv\",\n \"def build_vocab(self, corpus):\\n if self.vocabulary_counts != None:\\n logger.debug(\\\"building vocabulary from provided frequency map\\\")\\n vocab = self.vocabulary_counts\\n else:\\n logger.debug(\\\"default vocabulary building\\\")\\n super(Skipgram, self).build_vocab(corpus)\\n return\\n\\n # assign a unique index to each word\\n self.vocab, self.index2word = {}, []\\n\\n for word, count in vocab.iteritems():\\n v = Vocab()\\n v.count = count\\n if v.count >= self.min_count:\\n v.index = len(self.vocab)\\n self.index2word.append(word)\\n self.vocab[word] = v\\n\\n logger.debug(\\\"total %i word types after removing those with count<%s\\\" % (len(self.vocab), self.min_count))\\n\\n if self.hs:\\n # add info about each word's Huffman encoding\\n self.create_binary_tree()\\n if self.negative:\\n # build the table for drawing random words (for negative sampling)\\n self.make_table()\\n # precalculate downsampling thresholds\\n self.precalc_sampling()\\n self.reset_weights()\",\n \"def calc_doc_ret_MAP():\\n \\n# docs_norm_scores_dicts_path = linux_base_path+\\\"/docs_norm_scores_dicts\\\"\\n claim_rel_docno_dict = read_pickle(\\\"claim_rel_docno_dict\\\") #key is clm, value is a set of the relevant docno\\n# nDCG_MAP_res = base_path +\\\"\\\\\\\\nDCG_MAP_res\\\\\\\\\\\"\\n# docs_norms_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\\\\\\\\\"\\n docs_norms_path = linux_base_path+\\\"/docs_norm_scores_dicts/\\\"\\n nDCG_MAP_res = linux_base_path +\\\"/nDCG_MAP_res/\\\"\\n \\n AP_cut_off = 1000\\n k_val = 100\\n p = 10\\n log = open(\\\"calc_doc_avg_nDCG_MAP_log_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),\\\"wb\\\")\\n res_file = open(nDCG_MAP_res+\\\"doc_ret_nDCG_MAP_res_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),\\\"wb\\\")\\n# each_params_AVGnDCG_MAP_dict = {} #key is alpha,beta,k_docs,lambda and val is the avg nDCG and MAP across all claims together\\n each_params_MAP_dict = {}\\n# NDCG_AP_all_claims_all_param_values = {}\\n AP_all_claims_all_param_values = {}\\n best_avg_nDCG = 0\\n best_MAP = 0 #across all claims in a given configuration, find the max measures\\n \\n# docs_norms_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\\\\\\\\\"\\n claims_dict = read_pickle(\\\"claim_dict\\\")\\n #count the number of sentences that were retrived that are in the true data....sum for each claim, then average.\\n \\n \\n for alpha in range(0,11,1): #change just for test!\\n for beta in range(0,10,1):\\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\\n NDCG_all_claims= {} #key is a claim, value is the nDCG\\n AP_all_claims= {} \\n AP_cut_off = 1000\\n curr_filename = docs_norms_path+\\\"clm_key_ranked_list_of_docs_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)\\n clm_key_ranked_list_of_docs_baseline = read_pickle(curr_filename) #key is qID and docid\\n #need to turn it to a list of docs\\n for clm in claim_list:\\n try:\\n# nDCG_score = utils_linux.calc_doc_emp_NDCG(curr_source,str(clm),clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]],p)\\n# NDCG_all_claims[clm] = nDCG_score\\n AP_score = utils_linux.calc_doc_AP_relevance(AP_cut_off,curr_source,clm,clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]])\\n AP_all_claims[clm] = AP_score\\n AP_all_claims_all_param_values[clm,alpha_f,beta_f,k_val] = AP_score\\n except Exception as err: \\n log.write('problem in calculations: in source: '+ curr_source+' in clm '+ claims_dict[str(clm)]+\\\" alpha:\\\"+str(alpha_f)+ \\\"beta:\\\"+str(beta_f)+\\\" \\\\n\\\" ) \\n for arg in err.args:\\n log.write(arg+\\\" \\\") \\n log.write(\\\"\\\\n\\\") \\n# average_NDCG = float(float(sum(NDCG_all_claims.values()))/float(len(NDCG_all_claims))) #across all claims...\\n# if average_NDCG > best_avg_nDCG:\\n# best_avg_nDCG = average_NDCG\\n# best_avg_nDCG_configuration = (alpha_f,beta_f,k_val)\\n MAP = float(float(sum(AP_all_claims.values()))/float(len(AP_all_claims)))\\n if MAP > best_MAP:\\n best_MAP = MAP\\n best_MAP_configuration = (alpha_f,beta_f,k_val)\\n each_params_MAP_dict[alpha_f,beta_f,k_val] = MAP\\n utils_linux.save_pickle(nDCG_MAP_res+\\\"doc_ret_NDCG_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),NDCG_all_claims)\\n utils_linux.save_pickle(nDCG_MAP_res+\\\"doc_ret_AP_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val),AP_all_claims)\\n# res_file.write(\\\"alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"|\\\"+\\\"AnDCG_\\\"+str(average_NDCG)+\\\"_MAP_\\\"+str(MAP)+\\\"\\\\n\\\")\\n res_file.write(\\\"alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"|_MAP_\\\"+str(MAP)+\\\"\\\\n\\\")\\n save_pickle(nDCG_MAP_res+\\\"doc_ret_NDCG_AP_all_claims_all_param_values_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),AP_all_claims_all_param_values)\\n save_pickle(nDCG_MAP_res+\\\"doc_ret_each_params_AVGnDCG_MAP_dict_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),each_params_MAP_dict)\\n# best_row = \\\"best_avg_nDCG|\\\"+str(best_avg_nDCG)+\\\"|best_avg_nDCG_configuration|\\\"+str(best_avg_nDCG_configuration[0])+\\\",\\\"+str(best_avg_nDCG_configuration[1])+\\\",\\\"+str(best_avg_nDCG_configuration[3])+\\\",\\\"+str(best_avg_nDCG_configuration[2])+\\\"|\\\"\\n best_row = \\\"best_MAP|\\\" +str(best_MAP)+\\\"|best_MAP_configuration|\\\"+str(best_MAP_configuration[0])+\\\",\\\"+str(best_MAP_configuration[1])+\\\",\\\"+str(best_MAP_configuration[2])\\n res_file.write(best_row)\\n res_file.close()\\n log.close()\",\n \"def documento():\\r\\n\\tpass\",\n \"def qwf(self, vw, ev, gp, psi_l, lai, dt):\\n\\t\\t#if the amount of water in storage is less than amount that will be absorbed by plant in timestep dt, then what's left will be absorbed \\n\\t qw = (self.gwf(self.psi_wf(self.vw,self.d1, self.d1, self.ns, self.tl), self.H, self.J)*(self.psi_wf(self.vw, self.d1, self.d1, self.ns, self.tl) - (ev*(1. - self.F_CAP))/(lai*gp) - psi_l)*lai)\\n\\t if self.vw == 0:\\n\\t return 0.\\n\\t elif self.vw*10**6 <= qw*dt:\\n\\t return (self.vw*10**6/dt)\\n\\t else:\\n\\t return qw\",\n \"def _compute_export_in_woo(self):\\n for rec in self:\\n rec.ks_export_in_woo = bool(rec.ks_woo_id)\",\n \"def test_continue_build() -> None:\\n tknzr = WsTknzr(is_uncased=True, max_vocab=-1, min_count=0)\\n tknzr.build_vocab(['a'])\\n tknzr.build_vocab(['b'])\\n tknzr.build_vocab(['c'])\\n assert tknzr.tk2id == {\\n BOS_TK: BOS_TKID,\\n EOS_TK: EOS_TKID,\\n PAD_TK: PAD_TKID,\\n UNK_TK: UNK_TKID,\\n 'a': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 1,\\n 'b': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 2,\\n 'c': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 3,\\n }\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def evaluate():\\n global dictionary, wv\\n count = 0\\n # To save the scores by distance and similarity\\n scores = np.zeros(6)\\n similar = np.zeros(6)\\n itr = len(dictionary)\\n logging.info('running evaluation for {0} samples'.format(itr))\\n for key in dictionary:\\n progress = (count / itr) * 100\\n d = dictionary[key].split('resource/')\\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\\n try:\\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\\n dtype=np.float32)\\n except KeyError:\\n itr -= 1\\n continue\\n if np.any(np.isnan(r)):\\n itr -= 1\\n continue\\n else:\\n if r.ndim == 2:\\n try:\\n # Mean of vector containing all word vectors\\n # obtained from abstract.\\n r = r.mean(axis=0).reshape(1, -1)\\n \\n # Obtain the vectors for the entity\\n mean_vec = mean_encoder(dictionary[key])\\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\\n mean_dist_vec = distance_encoder(dictionary[key])\\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\\n title_vec = title_mean(key)\\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\\n abstract_vec = abstract_encoder(key)\\n abstract_vec = abstract_vec.reshape(1, -1)\\n abstract_vec = abstract_vec / norm(abstract_vec)\\n random_vec = np.random.randn(100).reshape(1, -1)\\n zero_vec = np.zeros(100).reshape(1, -1)\\n \\n # Score the entity vectors\\n scores[0] += norm(r - mean_vec)\\n scores[1] += norm(r - mean_dist_vec)\\n scores[2] += norm(r - title_vec)\\n scores[3] += norm(r - abstract_vec)\\n scores[4] += norm(r - random_vec)\\n scores[5] += norm(r - zero_vec)\\n similar[0] += cosine_similarity(r, mean_vec)\\n similar[1] += cosine_similarity(r, mean_dist_vec)\\n similar[2] += cosine_similarity(r, title_vec)\\n similar[3] += cosine_similarity(r, abstract_vec)\\n similar[4] += cosine_similarity(r, random_vec)\\n similar[5] += cosine_similarity(r, zero_vec)\\n count += 1\\n print(count, end='\\\\r')\\n except (ValueError, KeyError) as _:\\n itr -= 1\\n continue\\n else:\\n itr -= 1\\n continue\\n # Normalize the scores to get a better\\n # comparison against the baselines.\\n scores = scores / norm(scores)\\n similar = similar / norm(similar)\\n print_summary(scores, similar)\",\n \"def _derW(self, w, x, y, z):\\n if _isscalar(w):\\n w_pos = max(min(self.wSearchFunc(self.w_list, w), self.w_n - 1), 1)\\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\\n else:\\n w_pos = self.wSearchFunc(self.w_list, w)\\n w_pos[w_pos < 1] = 1\\n w_pos[w_pos > self.w_n - 1] = self.w_n - 1\\n x_pos = self.xSearchFunc(self.x_list, x)\\n x_pos[x_pos < 1] = 1\\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\\n y_pos = self.ySearchFunc(self.y_list, y)\\n y_pos[y_pos < 1] = 1\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n z_pos = self.zSearchFunc(self.z_list, z)\\n z_pos[z_pos < 1] = 1\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n i = w_pos # for convenience\\n j = x_pos\\n k = y_pos\\n l = z_pos\\n beta = (x - self.x_list[j - 1]) / (self.x_list[j] - self.x_list[j - 1])\\n gamma = (y - self.y_list[k - 1]) / (self.y_list[k] - self.y_list[k - 1])\\n delta = (z - self.z_list[l - 1]) / (self.z_list[l] - self.z_list[l - 1])\\n dfdw = (\\n (\\n (1 - beta)\\n * (1 - gamma)\\n * (1 - delta)\\n * self.f_values[i, j - 1, k - 1, l - 1]\\n + (1 - beta) * (1 - gamma) * delta * self.f_values[i, j - 1, k - 1, l]\\n + (1 - beta) * gamma * (1 - delta) * self.f_values[i, j - 1, k, l - 1]\\n + (1 - beta) * gamma * delta * self.f_values[i, j - 1, k, l]\\n + beta * (1 - gamma) * (1 - delta) * self.f_values[i, j, k - 1, l - 1]\\n + beta * (1 - gamma) * delta * self.f_values[i, j, k - 1, l]\\n + beta * gamma * (1 - delta) * self.f_values[i, j, k, l - 1]\\n + beta * gamma * delta * self.f_values[i, j, k, l]\\n )\\n - (\\n (1 - beta)\\n * (1 - gamma)\\n * (1 - delta)\\n * self.f_values[i - 1, j - 1, k - 1, l - 1]\\n + (1 - beta)\\n * (1 - gamma)\\n * delta\\n * self.f_values[i - 1, j - 1, k - 1, l]\\n + (1 - beta)\\n * gamma\\n * (1 - delta)\\n * self.f_values[i - 1, j - 1, k, l - 1]\\n + (1 - beta) * gamma * delta * self.f_values[i - 1, j - 1, k, l]\\n + beta\\n * (1 - gamma)\\n * (1 - delta)\\n * self.f_values[i - 1, j, k - 1, l - 1]\\n + beta * (1 - gamma) * delta * self.f_values[i - 1, j, k - 1, l]\\n + beta * gamma * (1 - delta) * self.f_values[i - 1, j, k, l - 1]\\n + beta * gamma * delta * self.f_values[i - 1, j, k, l]\\n )\\n ) / (self.w_list[i] - self.w_list[i - 1])\\n return dfdw\",\n \"def _get_context_from_gdoc(self, key):\\n try:\\n content = self.export_xlsx(key)\\n data = process_xlsx(content)\\n if 'values' in data:\\n data = copy_global_values(data)\\n return data\\n except BadStatusLine:\\n # Stale connection, reset API and data\\n puts(\\\"Connection reset, reloading drive API\\\")\\n self.client = get_drive_api()\\n return self._get_context_from_gdoc(key)\",\n \"def test_validate_wc3(self):\\r\\n assert self.wc2_tree != 0\",\n \"def w(self): # pylint: disable=invalid-name\\n return self._w\",\n \"def vwf(self, vw, ev, gp, psi_l, lai, dt):\\n\\t return min(vw - self.qwf(self.vw, self.th, self.gp, self.psi_l, self.LAI, dt)*dt/10.**6, self.ZW)\",\n \"def computeProportionWings(self):\\n self.ws_me_pointsA = []\\n self.ws_me_pointsIy = []\\n self.ws_me_pointsIz = []\\n self.ws_me_pointsJ = []\\n for i in range(self.nWings):\\n wingIndex = i+1\\n wingNnodes = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"FEM\\\"][\\\"nodesFEM\\\"]\\n if self.tigl.wingGetSymmetry(i+1) != 0:\\n wingNnodes = 2*wingNnodes - 1\\n inputMaxA = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"A\\\"]\\n inputMaxIy = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"Iy\\\"]\\n inputMaxIz = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"Iz\\\"]\\n inputMaxJ = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"J\\\"]\\n inputInterpolationType = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"FEM\\\"][\\\"mechanicalInterpolationType\\\"]\\n index = np.argmax(self.ws_me_pointsInitArea[i])\\n wingMaxArea = self.ws_me_pointsInitArea[i][index]\\n\\n if inputInterpolationType == \\\"constant\\\":\\n exposant = 0\\n elif inputInterpolationType == \\\"linear\\\":\\n exposant = 1\\n elif inputInterpolationType == \\\"quadratic\\\":\\n exposant = 2\\n else:\\n logger.error(\\\"Wing mechanical properties distribution is\\\")\\n logger.error(\\\"wrong. Accepted values are \\\\\\\"constant\\\\\\\",\\\")\\n logger.error(\\\"\\\\\\\"linear\\\\\\\", \\\\\\\"quadratic\\\\\\\"\\\")\\n sys.exit()\\n\\n coef = np.empty(wingNnodes)\\n self.w_m_pointsA = np.empty(wingNnodes)\\n self.w_m_pointsIy = np.empty(wingNnodes)\\n self.w_m_pointsIz = np.empty(wingNnodes)\\n self.w_m_pointsJ = np.empty(wingNnodes)\\n for j in range(wingNnodes):\\n coef[j] = self.ws_me_pointsInitArea[i][j]/wingMaxArea\\n self.w_m_pointsA[j] = inputMaxA * coef[j]\\n self.w_m_pointsIy[j] = inputMaxIy * coef[j]**exposant\\n self.w_m_pointsIz[j] = inputMaxIz * coef[j]**exposant\\n self.w_m_pointsJ[j] = inputMaxJ * coef[j]**exposant\\n self.ws_me_pointsA.append(self.w_m_pointsA)\\n self.ws_me_pointsIy.append(self.w_m_pointsIy)\\n self.ws_me_pointsIz.append(self.w_m_pointsIz)\\n self.ws_me_pointsJ.append(self.w_m_pointsJ)\",\n \"def processVS(self, model=\\\"okapi\\\", l = 0.5):\\n self.results[model] = {}\\n for query in self.queries:\\n res = {}\\n for doc in query.docs.values():\\n sum_otf = 0.0\\n for term in doc.terms:\\n if model == \\\"okapi\\\":\\n sum_otf += self.okapiTF(term.tf, doc.dlen, self.avgdlen)\\n if model == \\\"tfidf\\\":\\n sum_otf += self.tfidf(term.tf, term.df, doc.dlen, self.avgdlen, self.num_docs)\\n if model == \\\"bm25\\\":\\n sum_otf += self.bm25(term.tf, term.df, query.query_tf[term.term], doc.dlen, self.avgdlen, self.num_docs)\\n res[doc.id] = sum_otf\\n self.results[model][query.id] = res\",\n \"def unknown(self, w):\\n return True\",\n \"def generate_wordcloud():\\r\\n # \\\"\\\"\\\"Join list into one string\\\"\\\"\\\"\\r\\n # unique_string = (\\\" \\\").join(prioritized)\\r\\n # wc = WordCloud(background_color=\\\"black\\\", width=2000, height=2000,contour_color=\\\"black\\\", max_words=30, relative_scaling=0.5, normalize_plurals=False).generate(unique_string)\\r\\n\\r\\n \\\"\\\"\\\"Generate word cloud based on dictionary\\\"\\\"\\\"\\r\\n wc = WordCloud(background_color=\\\"black\\\", width=2000, height=2000, contour_color=\\\"black\\\", max_words=30,\\r\\n relative_scaling=0.5, normalize_plurals=False).generate_from_frequencies(priority_dict)\\r\\n\\r\\n fig = plt.figure(figsize=(10, 7))\\r\\n fig.suptitle(\\\"Top 30 Most Visited Websites\\\")\\r\\n plt.imshow(wc, interpolation=\\\"bilinear\\\")\\r\\n plt.axis(\\\"on\\\")\\r\\n plt.show()\",\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 w(self):\\n return self._w\",\n \"def filter_w2v_nomenclature(w2vfilename,filter_nomenclature):\\n V = set(filter_nomenclature)\\n wordlist = []\\n veclist = [] \\n istream = open(w2vfilename)\\n istream.readline() #skips w2v header\\n for line in istream:\\n fields = line.split()\\n word = fields[0]\\n if word in V:\\n vec = np.array([float(elt) for elt in fields[1:]])\\n wordlist.append(word)\\n veclist.append(vec)\\n istream.close()\\n M = np.array(veclist)\\n return (wordlist,M)\",\n \"def check_for_correction(dummy_arg):\\n #space_indexes = []\\n #new_space_indexes = []\\n #punct_dict = {}\\n\\n # Get current document and attributes for doc\\n doc = XSCRIPTCONTEXT.getDocument()\\n selection_supplier = doc.getCurrentController()\\n indexAccess = selection_supplier.getSelection()\\n #count = indexAccess.getCount() # don't really need this right now. Only loop once..\\n\\n # get cursor to write corrected word highlighted in blue\\n text = doc.Text\\n vis_cursor = doc.getCurrentController().getViewCursor() # visible cursor in OpenOffice\\n nvis_cursor= vis_cursor.getText().createTextCursorByRange(vis_cursor) # not visible cursor place at same place as visible\\n \\n # set str and txt for use\\n highlighted_txt = indexAccess.getByIndex(0)\\n highlighted_str = highlighted_txt.getString()\\n \\n # strip punctuation from string\\n punctuation = set(string.punctuation)\\n '''\\n for letter in highlighted_str:\\n if letter == ' ':\\n sp_index = highlighted_str.index(letter)\\n space_indexes.append(sp_index + len(space_indexes))\\n highlighted_str = highlighted_str.replace(letter,'',1)\\n \\n for index in space_indexes:\\n highlighted_str = highlighted_str[:index] + ' ' + highlighted_str[index:]\\n\\n \\n for letter in highlighted_str:\\n if letter in punctuation:\\n punc_index = highlighted_str.index(letter)\\n punct_dict[letter] = punc_index\\n highlighted_str = highlighted_str.replace(letter,'',1)\\n '''\\n highlighted_str = ''.join(ch for ch in highlighted_str if ch not in punctuation) \\n highlighted_str_arr = highlighted_str.split()\\n\\n corrected_sent = highlighted_str # correct sentence to be displayed at end\\n\\n # check for correction for each word highlighted\\n for word in highlighted_str_arr:\\n\\n if len(highlighted_str) == 0:\\n return None\\n\\n # call make_correction helper function to correct highlighted word\\n else:\\n correction = make_correction(word)\\n \\n # make sure new correction word is present\\n if correction:\\n # get parent window from document\\n parentwin = doc.CurrentController.Frame.ContainerWindow\\n # make window\\n correction_query_str = word + \\\" => \\\" + correction # show old word => new word\\n prompt = MessageBox(parentwin, correction_query_str, \\\"Correction:\\\", MESSAGEBOX, BUTTONS_YES_NO)\\n \\n # if yes button pressed, replace word\\n if prompt == 2:\\n # replace wrong word with corrected word\\n corrected_sent = corrected_sent.replace(word, correction)\\n '''\\n for letter in corrected_sent:\\n if letter == ' ':\\n sp_index = corrected_sent.index(letter)\\n new_space_indexes.append(sp_index + len(new_space_indexes))\\n corrected_sent = corrected_sent.replace(letter,'',1)\\n \\n for index in new_space_indexes:\\n corrected_sent = corrected_sent[:index] + ' ' + corrected_sent[index:]\\n \\n \\n punc_location = {}\\n for key in punct_dict:\\n p_index = punct_dict[key]\\n for s_index in space_indexes:\\n if abs(p_index-s_index) == 1:\\n location_index = space_indexes.index(s_index)\\n if p_index-s_index > 0:\\n punc_location[key] = new_space_indexes[location_index+1]\\n else:\\n punc_location[key] = new_space_indexes[location_index-1]\\n\\n\\n for key in punc_location:\\n index = punc_location[key]\\n corrected_sent = key\\n #corrected_sent = corrected_sent[:index] + key + corrected_sent[index:]\\n ''' \\n #highlighted_txt.setString(highlighted_str)\\n highlighted_txt.setString(corrected_sent) # replace old word with nothing\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5783301","0.5585813","0.54354393","0.5363023","0.5359201","0.5240661","0.52019274","0.5175359","0.5097325","0.5092165","0.5047512","0.5047512","0.5047512","0.5030539","0.50301886","0.50111204","0.5002621","0.4978421","0.49574295","0.49345815","0.4929732","0.49276966","0.49224955","0.48825747","0.48674443","0.48198953","0.47900927","0.4783557","0.47778416","0.4764446","0.47610787","0.47452155","0.47341436","0.47251794","0.47227287","0.47226235","0.47178805","0.47166744","0.47109485","0.47087085","0.47001857","0.46982032","0.46911627","0.4687101","0.4678976","0.46771535","0.46751875","0.4669808","0.46532643","0.4643657","0.4630475","0.46268874","0.46244684","0.46219665","0.46209285","0.46135232","0.4609821","0.4605284","0.46034026","0.45922187","0.45777607","0.4562583","0.4540343","0.45397195","0.4530747","0.4528041","0.45277905","0.45274043","0.45264348","0.45255986","0.4524743","0.45241287","0.45239878","0.45229664","0.4522625","0.4515914","0.4509237","0.45088106","0.45063728","0.45024818","0.4499421","0.4499421","0.4499421","0.4499421","0.4499421","0.4499421","0.449726","0.44965044","0.44916135","0.44876495","0.4481737","0.44809246","0.44776756","0.44773614","0.44757453","0.44728482","0.4467317","0.44666865","0.44615364","0.4458178"],"string":"[\n \"0.5783301\",\n \"0.5585813\",\n \"0.54354393\",\n \"0.5363023\",\n \"0.5359201\",\n \"0.5240661\",\n \"0.52019274\",\n \"0.5175359\",\n \"0.5097325\",\n \"0.5092165\",\n \"0.5047512\",\n \"0.5047512\",\n \"0.5047512\",\n \"0.5030539\",\n \"0.50301886\",\n \"0.50111204\",\n \"0.5002621\",\n \"0.4978421\",\n \"0.49574295\",\n \"0.49345815\",\n \"0.4929732\",\n \"0.49276966\",\n \"0.49224955\",\n \"0.48825747\",\n \"0.48674443\",\n \"0.48198953\",\n \"0.47900927\",\n \"0.4783557\",\n \"0.47778416\",\n \"0.4764446\",\n \"0.47610787\",\n \"0.47452155\",\n \"0.47341436\",\n \"0.47251794\",\n \"0.47227287\",\n \"0.47226235\",\n \"0.47178805\",\n \"0.47166744\",\n \"0.47109485\",\n \"0.47087085\",\n \"0.47001857\",\n \"0.46982032\",\n \"0.46911627\",\n \"0.4687101\",\n \"0.4678976\",\n \"0.46771535\",\n \"0.46751875\",\n \"0.4669808\",\n \"0.46532643\",\n \"0.4643657\",\n \"0.4630475\",\n \"0.46268874\",\n \"0.46244684\",\n \"0.46219665\",\n \"0.46209285\",\n \"0.46135232\",\n \"0.4609821\",\n \"0.4605284\",\n \"0.46034026\",\n \"0.45922187\",\n \"0.45777607\",\n \"0.4562583\",\n \"0.4540343\",\n \"0.45397195\",\n \"0.4530747\",\n \"0.4528041\",\n \"0.45277905\",\n \"0.45274043\",\n \"0.45264348\",\n \"0.45255986\",\n \"0.4524743\",\n \"0.45241287\",\n \"0.45239878\",\n \"0.45229664\",\n \"0.4522625\",\n \"0.4515914\",\n \"0.4509237\",\n \"0.45088106\",\n \"0.45063728\",\n \"0.45024818\",\n \"0.4499421\",\n \"0.4499421\",\n \"0.4499421\",\n \"0.4499421\",\n \"0.4499421\",\n \"0.4499421\",\n \"0.449726\",\n \"0.44965044\",\n \"0.44916135\",\n \"0.44876495\",\n \"0.4481737\",\n \"0.44809246\",\n \"0.44776756\",\n \"0.44773614\",\n \"0.44757453\",\n \"0.44728482\",\n \"0.4467317\",\n \"0.44666865\",\n \"0.44615364\",\n \"0.4458178\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.49491084"},"document_rank":{"kind":"string","value":"19"}}},{"rowIdx":12896,"cells":{"query":{"kind":"string","value":"pr's are all sorted as pr_wc are sorted in increasing order (in column idx) However, g's are not sorted. Sort g's in increasing order (in column idx)"},"document":{"kind":"string","value":"def get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode):\r\n cnt_list=[]\r\n for b, g_wo1 in enumerate(g_wo):\r\n g_wc1 = g_wc[b]\r\n pr_wc1 = pr_wc[b]\r\n pr_wo1 = pr_wo[b]\r\n pr_wn1 = len(pr_wo1)\r\n g_wn1 = g_wn[b]\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx = argsort(array(g_wc1))\r\n\r\n g_wo1_s = array(g_wo1)[idx]\r\n g_wo1_s = list(g_wo1_s)\r\n elif mode == 'train':\r\n # due to tearch forcing, no need to sort.\r\n g_wo1_s = g_wo1\r\n else:\r\n raise ValueError\r\n\r\n if type(pr_wo1) != list:\r\n raise TypeError\r\n if g_wo1_s == pr_wo1:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n return cnt_list"},"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 _sort(self):\n self.rows.sort(key=lambda x: (x['PERC1'], x['EQ'], x['PASS'], x['W2']),\n reverse=True)\n\n rank = 0\n prev_perc = 0\n prev_rank = 0\n for row in self.rows:\n if row[\"NR\"] == 0:\n # Something has already populated NR as 0 - so we set rank as\n # 0 too\n row['_RANK'] = 0\n row['_NR'] = 0\n continue\n\n # Increment our count\n rank += 1\n if row['PERC1'] == prev_perc:\n row['NR'] = \"\"\n row['_NR'] = prev_rank # I.e. joint 6th will be 6 here\n row['_RANK'] = rank # I.e. joint 6th could be 7, or 8 etc. here\n else:\n row['NR'] = rank\n row['_NR'] = rank\n row['_RANK'] = rank\n prev_perc = row['PERC1']\n prev_rank = rank","def rank_drawr_property(final_spreadsheet_df, pg_network_n1_names):\n prop_spreadsheet_df = final_spreadsheet_df.loc[pg_network_n1_names]\n prop_spreadsheet_df.iloc[:, :-1] = prop_spreadsheet_df.iloc[:, :-1].apply(\n lambda x: (x - prop_spreadsheet_df['base']).sort_values(ascending=0).index.values)\n prop_spreadsheet_df = prop_spreadsheet_df.drop('base', 1)\n\n return prop_spreadsheet_df","def sort_table(table, sats_table):","def sort_index(self):\n def s(t):\n return tuple(sorted(t, key=self.clade_order))\n self.scf.index = self.scf.index.map(s)\n self.scf.index.names = [s.split('_')[0] for s in self.scf.index[0]]","def sort_priors(self):\n return","def order_ideal(self, gens):","def sortby(self):\n ...","def data_sort(gdf,str):\n gdf = gdf.sort_values(by = [str])\n \n return gdf","def sort(self):\n for i in range(self.num):\n for j in range(i,0,-1):\n if self.genepool[0][j] < self.genepool[0][j-1]:\n self.genepool[0][j], self.genepool[0][j-1] = self.genepool[0][j-1], self.genepool[0][j]\n else:\n break\n for i in range(self.num):\n for j in range(i,0,-1):\n if self.genepool[1][j] < self.genepool[1][j-1]:\n self.genepool[1][j], self.genepool[1][j-1] = self.genepool[1][j-1], self.genepool[1][j]\n else:\n break","def oldsortslice(self):\n ...","def __get_score_ordered(scores, idx):\t\n\treturn [x[1][idx] for x in sorted(scores.items())]","def sort_by_idxs(self, idx_order):\n self.Nx = [self.Nx[idx] for idx in idx_order]\n self.dictionary = h.dictionary.Dictionary(\n [self.dictionary.tokens[idx] for idx in idx_order])\n\n # We are no longer sorted according to unigram frequencies.\n self.sorted = False","def part_build_order(self):\n priority = []\n for geo_item in self.build_order:\n if geo_item in self.parts:\n priority += [geo_item]\n return priority","def reorder_bgc_data(df):\n st_col_list = ['time','lat','lon','depth','year','month','week','dayofyear','float_id','cycle']\n st_cols =df[st_col_list]\n non_st_cols = df.drop(st_col_list, axis=1)\n reorder_df = pd.concat([st_cols, non_st_cols], axis=1, sort=False)\n \n sci_col_list = [\"SCIENTIFIC_CALIB_COEFFICIENT\",\"SCIENTIFIC_CALIB_COMMENT\",\"SCIENTIFIC_CALIB_DATE\",\"SCIENTIFIC_CALIB_EQUATION\"]\n sci_cols =reorder_df[sci_col_list]\n non_sci_cols = reorder_df.drop(sci_col_list, axis=1)\n neworder_df = pd.concat([non_sci_cols,sci_cols], axis=1, sort=False)\n return neworder_df","def sort_key(self):\n ...","def renumber_cells_ordering(self):\n Nactive = sum(~self.cells['deleted'])\n return np.argsort( self.cells['deleted'],kind='mergesort')[:Nactive]","def nat_sort(x, df):\n unordered = df.swing_drop.tolist()\n reordered = natsorted(unordered, alg=ns.IGNORECASE)\n return reordered.index(x)","def set_trec_order(self):\n for k in self._run:\n self._run[k].sort(key=lambda x:(x.get_score(),x.get_doc()),reverse=True)\n for r in self._run[k]:\n print r.get_str()","def sort(self):\n \n ct=[]\n rt=[]\n wr=[]\n # search for tags that aren't in the right position\n for i in range(len(self.contigs)):\n c = self.contigs[i]\n if c.wa:\n if not self.wa:\n self.wa=[]\n self.wa.extend(c.wa)\n if c.ct:\n newcts=[ct_tag for ct_tag in c.ct if ct_tag.name!=c.name]\n map(self.contigs[i].ct.remove,newcts)\n ct.extend(newcts)\n for j in range(len(c.reads)):\n r = c.reads[j]\n if r.rt:\n newrts=[rt_tag for rt_tag in r.rt if rt_tag.name!=r.rd.name]\n map(self.contigs[i].reads[j].rt.remove,newrts)\n rt.extend(newrts)\n if r.wr:\n newwrs=[wr_tag for wr_tag in r.wr if wr_tag.name!=r.rd.name]\n map(self.contigs[i].reads[j].wr.remove,newwrs)\n wr.extend(newwrs)\n # now sort them into their proper place\n for i in range(len(self.contigs)):\n c = self.contigs[i]\n for ct_tag in ct:\n if ct_tag.name==c.name:\n if self.contigs[i].ct is None:\n self.contigs[i].ct=[]\n self.contigs[i].ct.append(ct_tag)\n if rt or wr:\n for j in range(len(c.reads)):\n r = c.reads[j]\n for rt_tag in rt:\n if rt_tag.name==r.rd.name:\n if self.contigs[i].reads[j].rt is None:\n self.contigs[i].reads[j].rt=[]\n self.contigs[i].reads[j].rt.append(rt_tag)\n for wr_tag in wr:\n if wr_tag.name==r.rd.name:\n if self.contigs[i].reads[j].wr is None:\n self.contigs[i].reads[j].wr=[]\n self.contigs[i].reads[j].wr.append(wr_tag)","def sort():\n return -1","def sort(self):\n sort_key = self.data.chromosome.apply(sorter_chrom)\n self.data = (\n self.data.assign(_sort_key_=sort_key)\n .sort_values(by=[\"_sort_key_\", \"start\", \"end\"], kind=\"mergesort\")\n .drop(\"_sort_key_\", axis=1)\n .reset_index(drop=True)\n )","def sort(self):\n for i in range(self.num):\n for j in range(i,0,-1):\n if self.genepool[0][j].fitness < self.genepool[0][j-1].fitness:\n self.genepool[0][j], self.genepool[0][j-1] = self.genepool[0][j-1], self.genepool[0][j]\n else:\n break\n for i in range(self.num):\n for j in range(i,0,-1):\n if self.genepool[1][j].fitness < self.genepool[1][j-1].fitness:\n self.genepool[1][j], self.genepool[1][j-1] = self.genepool[1][j-1], self.genepool[1][j]\n else:\n break","def sort(self, A, index, p, r, rc_arr):\n\n if p < r:\n q = (p + r) // 2\n\n self.sort(A, index, p, q, rc_arr)\n self.sort(A, index, q + 1, r, rc_arr)\n self.merge(A, index, p, q, r, rc_arr)","def reorder( self ):\n self.sorted.sort(self.compareFunction)","def sort_processes(ps_df: pd.DataFrame, user_sort: list) -> pd.DataFrame:\n result_df = ps_df.sort_values(by=user_sort, ascending=True)\n return result_df","def sorting_generator(G,desired_numberofcolumns):\n dimension = len(G)\n\n if dimension == desired_numberofcolumns:\n return G , None\n indexlist = np.argsort(np.linalg.norm( G ,axis=0 ,ord = None))\n sortedG = (G)[:,indexlist]\n G_untouched = sortedG[: , - (desired_numberofcolumns - dimension ): ]\n G_reduced = sortedG[: , : -(desired_numberofcolumns - dimension ) ]\n \n return G_reduced , G_untouched","def resort_couplings(J,sortIx):\n return","def SortL(L, g):\n for i in range(len(L)):\n L[i, 0] = i\n L[i, 1] = alpha[i]\n L[i, 2] = y_train[i]*g[i]\n L = sorted(L, key=itemgetter(2))\n L = np.array(L)\n return L","def ordering(self):\n value = []\n for i in self:\n if isinstance(i, PQ):\n value.extend(i.ordering())\n else:\n value.append(i)\n\n return value","def analyse_and_sort(self, df):\n if (type(df) is pd.Series):\n df = df.to_frame(\"score\")\n elif (type(df) is pd.DataFrame):\n df.columns = [\"score\"]\n df = self._filter(df)\n df = self._argrelmax(df)\n df = self._drop_close_extrema(df) # by = [deb1[0]]\n return df.sort_values(by=[\"score\"])[::-1]","def continuousOrder(snap):\n idx = computeIncreasingGridIndex(snap)\n idxIdx = idx.argsort()\n \n new = snap.copy()\n\n for i, ind in enumerate(idxIdx):\n new[i] = snap[ind]\n continue\n \n return new","def pdc_pivot(dh: DataHandler):\n df = dh.get(\"o_prices\")\n\n df = df.reset_index().pivot(index=\"t\", columns=\"r\")\n\n for col in df.columns:\n df[col] = sorted(df[col])\n\n df = df.reset_index(drop=True)\n return df","def _sort(self):\n self.population.sort()\n self.population.reverse()","def sort_challengers_by_points(self):\n if not self.isOrdered:\n order = []\n for k, i in self.scores.items():\n order.append((i, k))\n order.sort()\n\n nb = len(self.challengers)\n for i, d in enumerate(order):\n self.challengers[nb - i - 1] = d[1]\n self.isOrdered = True\n return self.challengers","def get_sorted_parties():\n return list(dfSeatsPerPartyBy2ndVotes.sort_values(by=[\"party\"])[\"party\"])","def sort_data(df, col_order=[\"id\", 'event_name', 'specialty', 'plan_type']):\n df.sort_values(col_order, inplace = True)\n df.reset_index(drop=1, inplace=True)\n return df","def _cmplx_sort(p):\n indx = cupy.argsort(cupy.abs(p))\n return cupy.take(p, indx, 0), indx","def sort_restos(filtered_table):\n\tdf = pd.DataFrame(filtered_table).T\n\tdf = df.sort(columns=columns['time_to_resto'])\n\n\treturn df.index","def part_build_order(self) -> List[str]:\n priority = []\n for geo_item in self.build_order:\n if geo_item in self.parts and isinstance(self.parts[geo_item], Polygon):\n priority += [geo_item]\n return priority","def sort_results(self):\n pass","def reversesort(self):\n ...","def sortColors(self, nums: List[int]) -> None:\n\n def quick_sort(ary, gte_idx, lte_idx) -> None:\n\n # 재귀 탈출조건\n if lte_idx - gte_idx < 1:\n return\n\n # 임의의 위치를 pivot으로 지정 (여기선 가운데 값)\n init_pivot_idx = (gte_idx + lte_idx) // 2\n\n # print(\"test:\", [str(p) if gte_idx <= p_idx <= lte_idx else \"_\" for p_idx, p in enumerate(ary)])\n # pivot 값을 맨 앞의 값과 swap한다 (순차적으로 읽으면서 pivot과 비교할거니까)\n ary[gte_idx], ary[init_pivot_idx] = ary[init_pivot_idx], ary[gte_idx]\n\n # gte_idx+1부터 차례로 읽으면서 pivot보다 작은 값이 있으면\n # 읽은 범위 내의 pivot보다 큰 값 중 맨 앞의 것과 swap해준다\n bigger_idx = gte_idx + 1\n for i in range(gte_idx + 1, lte_idx + 1):\n # 맨 앞의 pivot과 비교\n if ary[i] < ary[gte_idx]:\n ary[i], ary[bigger_idx] = ary[bigger_idx], ary[i]\n bigger_idx += 1\n # print(\"test:\", [str(p) if gte_idx <= p_idx <= lte_idx else \"_\" for p_idx, p in enumerate(ary)])\n\n # 맨 앞에 있던 pivot을 pivot보다 큰 범위의 바로 앞의 값과 swap\n ary[gte_idx], ary[bigger_idx - 1] = ary[bigger_idx - 1], ary[gte_idx]\n # print(\"test:\", [str(p) if gte_idx <= p_idx <= lte_idx else \"_\" for p_idx, p in enumerate(ary)])\n\n # recursion으로 좌우 분할정복\n pivot_idx = bigger_idx - 1\n quick_sort(ary, gte_idx, pivot_idx - 1)\n quick_sort(ary, pivot_idx + 1, lte_idx)\n\n quick_sort(nums, 0, len(nums) - 1)","def sort(self):\n\n # momentarily convert into numpy, to take advantage of their easy \n # sorting.\n top_indices = np.argsort([-n for n in self.Nx])\n self.Nx = [self.Nx[i] for i in top_indices]\n self.dictionary = h.dictionary.Dictionary([\n self.dictionary.tokens[i] for i in top_indices])\n\n self.sorted = True\n\n return top_indices","def sorted(self): \n pass","def _sort_dataframe(self, dataframe):\r\n print('Not allowed')","def _sort(self, row):\n if not self._head:\n self._head = self._create_head(row)\n if self._args.head:\n return row\n\n if 'key' not in self._state:\n self._state['key'] = self._replace_fields(self._args.key)\n\n r = list(map(self._convert, row))\n self._sorting_insert(self._result, r, key=lambda r: eval(self._state['key']))","def toposort(prereqs_d):\r\n\r\n# all1 = set(prereqs_d.keys())\r\n# all2 = set()\r\n# for x, y in prereqs_d.items():\r\n# all2.update(y)\r\n# print all1.difference(all2)\r\n\r\n seq = []\r\n done = set()\r\n postreqs_d = {}\r\n for x, prereqs in prereqs_d.items():\r\n for prereq in prereqs:\r\n postreqs_d.setdefault(prereq, set()).add(x)\r\n next = set([k for k in prereqs_d if not prereqs_d[k]])\r\n while next:\r\n bases = next\r\n next = set()\r\n for x in bases:\r\n done.add(x)\r\n seq.append(x)\r\n for x in bases:\r\n for postreq in postreqs_d.get(x, []):\r\n if not prereqs_d[postreq].difference(done):\r\n next.add(postreq)\r\n if len(prereqs_d) != len(seq):\r\n raise Exception(\"Cannot sort topologically: there might be cycles, \"\r\n \"prereqs_d does not have a key for each element or \"\r\n \"some orderings contain invalid elements.\")\r\n return seq","def sort_gefs_frame(frame):\n if frame is None:\n return frame\n else:\n return pd.DataFrame(np.sort(frame), index=frame.index)","def calc_ply_order(constraints, targets):\r\n if constraints.sym:\r\n ply_order = np.arange(targets.n_plies // 2 + targets.n_plies % 2)\r\n return ply_order\r\n\r\n order_before_sorting = np.arange(targets.n_plies)\r\n ply_order = np.zeros((targets.n_plies,), int)\r\n ply_order[0::2] = order_before_sorting[\r\n :targets.n_plies // 2 + targets.n_plies % 2]\r\n ply_order[1::2] = order_before_sorting[\r\n targets.n_plies // 2 + targets.n_plies % 2:][::-1]\r\n return ply_order","def sort(self, Ncol, order):\n self.emit(SIGNAL(\"layoutAboutToBeChanged()\"))\n self.arraydata = sorted(self.arraydata, key=operator.itemgetter(Ncol)) \n if order == Qt.DescendingOrder:\n self.arraydata.reverse()\n self.emit(SIGNAL(\"layoutChanged()\"))","def smartcotagsort(prefix, gwascotag, column='Cotagging', ascending=False,\n title=None):\n picklefile = '%s_%s.pickle' % (prefix, ''.join(column.split()))\n if os.path.isfile(picklefile):\n with open(picklefile, 'rb') as F:\n df, beforetail = pickle.load(F)\n else:\n print('Sorting File based on %s \"clumping\"...' % column)\n gwascotag.loc[:, 'm_size'] = norm(abs(gwascotag.slope), 10, 150)\n grouped = gwascotag.sort_values(by=column, ascending=ascending).groupby(\n column, as_index=False, sort=False).first()\n sorteddf = grouped.sort_values(by=column, ascending=ascending)\n tail = gwascotag[~gwascotag.snp.isin(sorteddf.snp)]\n beforetail = sorteddf.shape[0]\n df = sorteddf.copy()\n if not tail.empty:\n df = df.append(tail.sample(frac=1), ignore_index=True)\n df = df.reset_index(drop=True)\n df['index'] = df.index.tolist()\n with open(picklefile, 'wb') as F:\n pickle.dump((df, beforetail), F)\n idx = df.dropna(subset=['beta']).index.tolist()\n causals = df.loc[idx, :]\n size = df.m_size\n f, ax = plt.subplots()\n df.plot.scatter(x='pos', y='index', ax=ax, label=column)\n if not causals.empty:\n causals.plot.scatter(x='pos', y='index', marker='*', c='k', ax=ax,\n s=size[idx].values, label='Causals')\n if title is not None:\n plt.title(title)\n plt.tight_layout()\n plt.savefig('%s_%s.pdf' % (prefix, '_'.join(column.split())))\n plt.close()\n return df, beforetail","def _sort_ns(self):\n n = []\n for layer in self.structure:\n n.append(layer.get_index())\n n = np.asarray(n)\n return n","def sortdb():\n return sorted(donor_db.items(), key=sumdbkey, reverse=True)","def sort(self, Ncol, order):\n self.emit(SIGNAL(\"layoutAboutToBeChanged()\"))\n self.arraydata = sorted(self.arraydata, key=operator.itemgetter(Ncol)) \n if order != Qt.DescendingOrder:\n self.arraydata.reverse()\n self.emit(SIGNAL(\"layoutChanged()\"))","def sort_column_type(sorted_subgroups):\n new_document_list = []\n for page in sorted_subgroups:\n if page[0]:\n if page[1]:\n if page[2]:\n if page[1][0][0]['bbox'][1] < page[2][0][0]['bbox'][1]:\n new_document_list.append([page[0], page[1], page[2]])\n else:\n new_document_list.append([page[0], page[2], page[1]])\n else:\n new_document_list.append([page[0], page[1]])\n else:\n if page[2]:\n new_document_list.append([page[0], page[2]])\n else:\n new_document_list.append([page[0]])\n else:\n if page[1]:\n if page[2]:\n if page[1][0][0]['bbox'][1] < page[2][0][0]['bbox'][1]:\n new_document_list.append([page[1], page[2]])\n else:\n new_document_list.append([page[2], page[1]])\n else:\n new_document_list.append([page[1]])\n else:\n if page[2]:\n new_document_list.append([page[2]])\n return new_document_list","def sort(self, trans, query, ascending, column_name=None):\n return grids.GridColumn.sort(self, trans, query, ascending, column_name=\"history_id\")","def get_order(order, gt_idx_v):\n o = np.tile(order, (gt_idx_v.shape[0],1))\n g = np.expand_dims(gt_idx_v, 1)\n o = o - g\n l, c = np.where(o==0)\n return c # order[c[0]] = gt_idx_v[0]","def _sort_impact(sv_ndx, impact):\n\n if impact.ndim == 2:\n impact = np.sum(impact, axis=1)\n impact_list = zip(sv_ndx, impact)\n impact_list = sorted(sorted(impact_list, key=lambda x: x[0]), key=lambda x: abs(x[1]), reverse=True)\n\n sv_ndx, impact = zip(*impact_list)\n sv_ndx = np.array(sv_ndx)\n return sv_ndx, impact","def order_channels_by_distance(reference, channels, geom):\n coord_main = geom[reference]\n coord_others = geom[channels]\n idx = np.argsort(np.sum(np.square(coord_others - coord_main), axis=1))\n\n return channels[idx], idx","def _sort_dataframe(self, dataframe):\r\n columns = list(dataframe.columns)\r\n columns.sort()\r\n dataframe = dataframe[columns]\r\n return dataframe","def sort(self):\r\n self.candidates.sort(key=self.sortFitness)\r\n return","def sort_list_by_president_order(pronoun_proportion_list):\n return sorted(pronoun_proportion_list, key=lambda (k,d,v): (d,k,v))","def parse_sort_clump(fn, allsnps):\n # make sure allsnps is a series\n allsnps = pd.Series(allsnps)\n try:\n df = pd.read_table(fn, delim_whitespace=True)\n except FileNotFoundError:\n spl = fn.split('.')\n if spl[0] == '':\n idx = 1\n else:\n idx = 0\n fn = '.'.join(np.array(spl)[[idx, 1 + idx, -1]])\n if idx == 1:\n fn = '.%s' % fn\n df = pd.read_table(fn, delim_whitespace=True)\n SNPs = df.loc[:, 'SP2']\n tail = [x.split('(')[0] for y in SNPs for x in y.split(',') if x.split('(')[\n 0] != 'NONE']\n full = pd.DataFrame(df.SNP.tolist() + tail, columns=['SNP'])\n full = full[full.SNP.isin(allsnps)]\n rest = allsnps[~allsnps.isin(full.SNP)]\n df = pd.concat((full.SNP, rest)).reset_index(drop=False)\n df.rename(columns={'index': 'Index'}, inplace=True)\n return df","def calculate_points_sorted(self):\n self._scrabble_word_point_dict_sorted = dict(sorted(\n self.calculate_points().items(), key=lambda x: x[1], reverse=True))\n return self._scrabble_word_point_dict_sorted","def order_field(pivData):\n def inner(Ax, Ay, Bx, By):\n \"\"\"\n define inner product between two matrices\n \"\"\"\n return (Ax*Bx + Ay*By) / (Ax**2+Ay**2)**0.5 / (Bx**2+By**2)**0.5\n col = len(pivData.x.drop_duplicates())\n row = len(pivData.y.drop_duplicates())\n u = np.array(pivData.u).reshape((row, col))\n v = np.array(pivData.v).reshape((row, col))\n u1 = np.roll(u, -1, axis=0) # up\n v1 = np.roll(v, -1, axis=0) # up\n u2 = np.roll(u, 1, axis=0) # down\n v2 = np.roll(v, 1, axis=0) # down\n u3 = np.roll(u, 1, axis=1) # right\n v3 = np.roll(v, 1, axis=1) # right\n u4 = np.roll(u, -1, axis=1) # left\n v4 = np.roll(v, -1, axis=1) # left\n \n # do inner products with original matrix\n I1 = inner(u, v, u1, v1)\n I2 = inner(u, v, u2, v2)\n I3 = inner(u, v, u3, v3)\n I4 = inner(u, v, u4, v4)\n \n # average the products\n order = (I1 + I2 + I3 + I4) / 4\n \n return order","def _sort_ds(self):\n d = []\n for layer in self.structure:\n if (layer.type == 'Layer' or layer.type == 'Substrate'):\n d.append(layer.thickness)\n d.insert(0, self.structure[0].thickness)\n d.append(self.structure[-1].thickness)\n d = np.asarray(d)\n return d","def data_for_sorting():\n return RaggedArray([[1, 0], [2, 0], [0, 0]])","def sortFastND(fitnesses, k, probabilitiesForObjectives, first_front_only=False):\n if k == 0:\n return []\n\n N = len(fitnesses)\n pareto_fronts = []\n\n pareto_fronts.append([])\n pareto_sorted = 0\n dominating_fits = [0] * N\n dominated_fits = [list() for i in range(N)]\n\n # Rank first Pareto front\n for i, fit_i in enumerate(fitnesses):\n for j, fit_j in enumerate(fitnesses[i+1:], i+1):\n if isStochasticallyDominated(fit_i, fit_j,probabilitiesForObjectives):\n dominating_fits[i] += 1\n dominated_fits[j].append(i)\n elif isStochasticallyDominated(fit_j, fit_i,probabilitiesForObjectives):\n dominating_fits[j] += 1\n dominated_fits[i].append(j)\n if dominating_fits[i] == 0:\n pareto_fronts[-1].append(i)\n pareto_sorted += 1\n\n # Rank the next front until all individuals are sorted or the given\n # number of individual are sorted\n if not first_front_only:\n k = min(N, k)\n while pareto_sorted < k:\n pareto_fronts.append([])\n for indice_p in pareto_fronts[-2]:\n for indice_d in dominated_fits[indice_p]:\n dominating_fits[indice_d] -= 1\n if dominating_fits[indice_d] == 0:\n pareto_fronts[-1].append(indice_d)\n pareto_sorted += 1\n\n ranks = {}\n for i, front in enumerate(pareto_fronts):\n for j, idx in enumerate(front):\n front[j] = fitnesses[idx]\n ranks[fitnesses[idx]] = i\n\n return pareto_fronts, ranks","def sort_docs_by_price(self, reverse=False):\n self.documents_predicted_relevant.sort(key=lambda doc: doc.price, reverse=reverse)","def sort_final(y):\n with open(selected_pb, 'w') as outpb:\n pb = []\n for pr in y:\n pb.append({\n \"active\": pr[\"active\"],\n \"asn\": pr[\"asn\"],\n \"countrycode\": pr[\"countrycode\"],\n \"id\": pr[\"id\"],\n \"statecode\": pr[\"statecode\"],\n \"meta\": pr[\"meta\"],\n \"dist\": pr[\"dist\"]\n })\n datap = json.dumps(pb)\n outpb.write(datap)\n with open(selected_pb, 'r') as f:\n selected_dist = json.load(f)\n return selected_dist","def find_order(data, ending = '7day_avg', fn = np.mean):\n subset = data[[i for i in data.columns if i.endswith(ending)]]\n df = pd.DataFrame(data = [subset.columns.str[:12].tolist(),[fn(data.iloc[:,i]) for i in range(subset.shape[1])]],\n index = ['geoid','val']).T\n df = df.sort_values(by='val', ascending=False)\n df.index = range(df.shape[0])\n df['plot_group'] = [np.floor(i/3) + 1 for i in df.index]\n df['order_in_group'] = [i % 3 for i in df.index]\n \n return df","def Wsort_theo(D, k):\n\ta1b = k[\"A1B1\"]\n\tba1 = k[\"B1A1\"]\n\tba2 = k[\"C1A1\"]\n\tbc = k[\"B1C1\"]\n\t##\n\tASS = ASS_theo(D,k)\n\ttSS = SSt_theo(D,k)\n\t##\n\teps = a1b*ba2*(1 + D)*(ba1 + 2*bc + ba2*D)\n\t# zet = a1b*(ba1 - ba2)*ba2*(D-1)*(D+1)\n\tzet = a1b*(ba1 + ba2)*ba2*(D-1)*(D+1)\n\teta = 2*a1b*(ba1 + 2*bc + ba2*D)\n\t# the = 2*a1b*(ba1 - ba2)*(D-1)\n\tthe = 2*a1b*(ba1 + ba2)*(D-1)\n\t##\n\teps += zet*ASS\n\teta += the*ASS\n\tzet *= (0.5-ASS)\n\tthe *= (0.5-ASS)\n\t##\n\t# Wsort = tSS*(zet/the+(eps/eta-zet/the)*np.log((np.exp(1))+the/eta)/(1+the/eta))\n\tWsort = 0.5*ba2*(1+D)*tSS * np.log(D) \n\treturn -Wsort *2/(D+1)","def sort_reads(self): \n if not self.sampling:\n self.convert_to_array()\n self.reads = self.reads[self.reads[:,0].argsort()]","def sorted_gnames():\n return sorted(group_names.keys())","def reorder_cols(df):\n # print(df.columns)\n req_order = [df.columns.tolist()[-1]] + df.columns.tolist()[:-1]\n # print(req_order)\n df = df.loc[:, req_order]\n df = df.sort_values(by=['participant_id'], ignore_index=True)\n return df","def _order_fc_accordingto_networkname(sel, data):\n colname = list(data.columns)\n fcname = [name.split(' ')[1] if len(name.split(' '))\n > 1 else name.split(' ')[0] for name in colname]\n # sorted by the first item of each str\n idx = [i for i, v in sorted(enumerate(fcname), key=lambda x:x[1])]\n sorted_colname = [colname[id] for id in idx]\n sorted_data = data[sorted_colname]\n return sorted_data","def __sort_orders_by_price(self):\n self.orders = sorted(self.orders, key=lambda o: o.price, reverse=True)","def grouping(data,dis):\n cluRe = []\n for i in range(len(data)):\n cluRe.append(np.argsort(dis[i])[0])\n \n return np.asarray(cluRe)","def sort_partitions():\n usb_partitions = usb_partition_table()\n sorted_partitions = sorted(usb_partitions.items(), key=lambda x: x[1])\n return sorted_partitions","def gather_referring_orders (gdbval):\n# TODO: Somehow also note speculative references and attributes in\n# general\n vec = gdbval[\"referring\"]\n return [int(i[\"referring\"][\"order\"]) for i in vec_iter(vec)]","def sort(self, quant=None):\n if quant is None: # sort bei weight\n self.__sortlist = [key for key, values in sorted(self.__quantile.items(), key=lambda items: sum((10^quantille * count for quantille, count in enumerate(items[1].values()))))]\n elif isinstance(quant, int):\n self.__sortlist = [key for key, values in sorted(self.__quantile.items(), key=lambda items: items[1][quant])]","def _sort_compounds(self):\n self.sorted_molecules = sorted(self.values(), key=operator.attrgetter('criterion'))","def sort(self): # sort all entries to make room for new ones, determine best and worst\n ns = self.num_stored.value\n ys = np.asarray(self.ys[:ns])\n yi = ys.argsort()\n sortRuns = []\n for i in range(len(yi)):\n y = ys[yi[i]]\n xs = self.get_x(yi[i])\n sortRuns.append((y, xs))\n numStored = min(len(sortRuns),int(0.9*self.capacity)) # keep 90% best \n for i in range(numStored):\n self.replace(i, sortRuns[i][0], sortRuns[i][1])\n self.num_sorted.value = numStored \n self.num_stored.value = numStored \n return numStored","def transform_ordering(new_document_list):\n doc_list = []\n for page in new_document_list:\n # print(\"PAGE:\")\n page_list = []\n for col_type in page:\n # print(\"\\tCOL_TYPE:\")\n for column in col_type:\n # print(\"\\t\\tCOLUMN:\")\n for group in column:\n # print(\"\\t\\t\\t\" + str(group))\n page_list.append(group)\n doc_list.append(page_list)\n return doc_list","def sort_rows(self) -> list:\r\n\r\n # Sort Inner rows\r\n done_rows = []\r\n\r\n # Sort each row independently\r\n for r in self.rows:\r\n \r\n # Insertion Sort by x coordinate\r\n r = r[::-1] # reverse the list first to speed up sorting\r\n # this is faster because the list is\r\n # already partly reverse sorted\r\n \r\n sorted_row = []\r\n \r\n while r != []:\r\n\r\n # Take element from row\r\n el = r.pop()\r\n\r\n # Find where it belongs\r\n curr = 0\r\n while curr < len(sorted_row) and \\\r\n el.get_center()[0] > sorted_row[curr].get_center()[0]:\r\n \r\n curr += 1\r\n\r\n # Insert it there\r\n sorted_row.insert(curr, el)\r\n\r\n # collect sorted rows\r\n done_rows.append(sorted_row)\r\n\r\n\r\n # Sort Inter rows\r\n finished = []\r\n \r\n while done_rows != []:\r\n\r\n # Take out a row\r\n el = done_rows.pop()\r\n\r\n # Find where it belongs\r\n curr = 0\r\n while curr < len(finished) and \\\r\n (finished[curr][0].get_center()[1]\r\n + finished[curr][len(finished[curr]) - 1].get_center()[1]) \\\r\n / 2 < (el[0].get_center()[1]\r\n + el[len(el) - 1].get_center()[1]) / 2:\r\n curr += 1\r\n\r\n # Insert it there\r\n finished.insert(curr, el)\r\n\r\n\r\n # Set the sorted rows\r\n self.rows = finished","def gnome_sort(items):\n i = 0\n n = len(items)\n while i < n:\n if i and items[i] < items[i-1]:\n items[i], items[i-1] = items[i-1], items[i]\n i -= 1\n else:\n i += 1\n return items","def _build_sort1_table(key_itime, keys_map, header_dict,\n form, form_results, form_resultsi,\n disp_dict, stress_dict, strain_dict, force_dict,\n strain_energy_dict, gpstress_dict, log):\n is_results = False\n form_resultsi_subcase = []\n #for key, value in header_dict.items():\n #print(key, value)\n # (isubcase, analysis_code, sort_method,\n # count, ogs, superelement_adaptivity_index) = key\n key_itime0 = key_itime[0]\n key0 = key_itime0[0]\n # (isubcase, analysis_code, sort_method,\n # count, ogs, superelement_adaptivity_index, pval_step) = key\n subcase_id_old = key0[0]\n count_old = key0[3]\n ogs_old = key0[4]\n subtitle_old = key0[5]\n subtitle_old, label_old, superelement_adaptivity_index_old, unused_pval_step_old = keys_map[key0]\n del label_old\n del superelement_adaptivity_index_old\n\n # now that we have the data built, we put it in the form\n # in sorted order\n #\n # TODO: consider pval_step\n for key, itime in key_itime:\n # (isubcase, analysis_code, sort_method,\n # count, ogs, superelement_adaptivity_index, pval_step) = key\n #print('key =', key)\n subcase_id = key[0]\n count = key[3]\n ogs = key[4]\n #print('*ogs =', ogs)\n #subtitle = key[4]\n try:\n subtitle, unused_label, superelement_adaptivity_index, unused_pval_step = keys_map[key]\n except Exception:\n subcase_id = subcase_id_old\n subtitle = subtitle_old + '?'\n superelement_adaptivity_index = '?'\n raise\n\n #print('key =', key)\n if subcase_id != subcase_id_old or subtitle != subtitle_old or ogs != ogs_old:\n count_str = '' if count == 0 else ' ; opt_count=%s' % count_old\n ogs_str = '' if ogs == 0 else '; OGS=%s' % ogs_old\n subcase_str = 'Subcase %s; %s%s%s%s' % (\n subcase_id_old, subtitle_old, superelement_adaptivity_index, count_str, ogs_str)\n #print(subcase_str)\n res = (\n subcase_str.rstrip('; '),\n None,\n form_resultsi_subcase\n )\n form_resultsi.append(res)\n form_resultsi_subcase = []\n subcase_id_old = subcase_id\n subtitle_old = subtitle\n count_old = count\n ogs_old = ogs\n\n\n try:\n header = header_dict[(key, itime)]\n except KeyError: # this hits for strain energy\n msg = 'Missing (key, itime) in header_dict\\n'\n msg += ' key=%s\\n' % str(key)\n\n (subcase, analysis_code, sort_method,\n count, ogs, superelement_adaptivity_index, pval_step) = key\n msg += f' subcase={subcase}\\n'\n msg += f' analysis_code={analysis_code}\\n'\n msg += f' sort_method={sort_method}\\n'\n msg += f' count={count}\\n'\n msg += f' ogs={ogs}\\n'\n msg += f' superelement_adaptivity_index={superelement_adaptivity_index!r}\\n'\n msg += f' pval_step={pval_step!r}\\n'\n\n msg += ' itime=%s\\n' % itime\n msg += ' %s\\n' % str((key, itime))\n msg += 'Possible (key, time):\\n'\n for keyi in header_dict:\n msg += ' %s\\n' % str(keyi)\n #print(msg.rstrip())\n #print('expected = (%s, %r)\\n' % (str(key), itime))\n log.error(msg.rstrip() + '\\n')\n #self.log.error('expected = (%s, %r)\\n' % (str(key), itime))\n continue\n #raise KeyError(msg)\n try:\n header = header.strip()\n except Exception:\n print('header = %r' % header)\n raise\n\n\n form_outi = []\n form_out = (header, None, form_outi)\n disp_formi = disp_dict[(key, itime)]\n stress_formi = stress_dict[(key, itime)]\n strain_formi = strain_dict[(key, itime)]\n force_formi = force_dict[(key, itime)]\n strain_energy_formi = strain_energy_dict[(key, itime)]\n gpstress_formi = gpstress_dict[(key, itime)]\n if disp_formi:\n form_outi += disp_formi\n #form_outi.append(('Disp', None, disp_formi))\n if stress_formi:\n form_outi.append(('Stress', None, stress_formi))\n is_results = True\n if strain_formi:\n form_outi.append(('Strain', None, strain_formi))\n is_results = True\n if force_formi:\n form_outi.append(('Force', None, force_formi))\n is_results = True\n if strain_energy_formi:\n form_outi.append(('Strain Energy', None, strain_energy_formi))\n is_results = True\n if gpstress_formi:\n form_outi.append(('Grid Point Stresses', None, gpstress_formi))\n is_results = True\n\n if form_outi:\n is_results = True\n form_resultsi_subcase.append(form_out)\n #break\n\n #print(\"subcase_id = \", subcase_id)\n if subcase_id:\n count_str = '' if count == 0 else ' ; opt_count=%s' % count_old\n ogs_str = '' if ogs == 0 else '; OGS=%s' % ogs_old\n subcase_str = 'Subcase %s; %s%s%s' % (subcase_id, subtitle, count_str, ogs_str)\n #print('*', subcase_str)\n res = (\n subcase_str.strip('; '),\n None,\n form_resultsi_subcase\n )\n form_resultsi.append(res)\n assert len(form_out) > 0, form_out\n form_resultsi_subcase = []\n\n if is_results:\n form.append(form_results)\n assert len(form_out) > 0, form_out\n #print('formi =', formi)\n #print('form_out =', form_out)\n #print('form_resultsi =', form_resultsi)\n #print('form_results =', form_results)\n #print(form)\n #if len(formi):\n #form.append(form0)\n #print(form)\n #aa\n #print('form', form)\n #print('form_results =', form_results)\n return form","def sort_decls(self):\n\n #import simplecssbuilder\n #SHORTHAND_REL = simplecssbuilder.SHORTHAND_REL\n\n def decl_key(decl):\n \"\"\"key for sorting declarations\"\"\"\n prop = decl.split(':')[0] # get property name\n if str(prop) in SHORTHAND_REL_inv:\n return SHORTHAND_REL_inv[str(prop)]\n else:\n return str(prop)\n\n def sort_decls_clique(clique):\n \"\"\"Sort the declarations in clique\"\"\"\n (_,ps) = clique\n ps.sort(key=decl_key)\n\n # compute the inverse of SHORTHAND_REL\n SHORTHAND_REL_inv = dict()\n for k,vs in SHORTHAND_REL.iteritems():\n for v in vs:\n SHORTHAND_REL_inv[v] = k\n\n #print 'PRINTING CLIQUES'\n for clique in self.cliques:\n #print clique\n sort_decls_clique(clique)\n #print clique","def sortRegioni(tupla):\n\t\n\treturn int(tupla[0])","def selection_sort(self, data):\n for i in range(len(data)-1, 0, -1):\n i_max = 0\n for j in range(1, i+1):\n if data[j] > data[i_max]:\n i_max = j\n tmp = data[i]\n data[i] = data[i_max]\n data[i_max] = tmp\n print \"pass\", i, data","def order_output(self):\n self.output = self.output[self.cols]","def dmc_order(self):\n return sorted(self.lookup_table, key=lambda clr: int(clr.id) if clr.id.isdigit() else 0)","def recommendation_ranking(self):\n iu = self.final_recommendation_score_matrix()\n new_iu = []\n for row in iu:\n li = []\n temp = row\n if self.product != \"dist\":\n temp = -np.sort(-temp)\n for element in row:\n li.append(binary_search_opp(temp,element)+1) \n else:\n temp = np.sort(temp)\n for element in row:\n li.append(np.searchsorted(temp,element)+1)\n new_iu.append(li)\n return np.array(new_iu)","def sort(self):\r\n\t\treturn sorted(self.sample)","def sort_weight(self):\n self._elements = list(\n _[-1] for _ in sorted((e.weight, e.value, e) for e in self)\n )","def getorder(columns, langs):\n order = []\n for lang in langs:\n i = 0\n for col in columns:\n if col == lang:\n order.append(i)\n i += 1\n if len(order) != len(langs):\n print(\"Either missing a language or have a duplicate\\n\")\n return order","def sort_values(self):\r\n for loopindex in range(0, self.population_size):\r\n index = self.cost_populations.index(min(self.cost_populations))\r\n \r\n if loopindex < int(self.population_size / 2):\r\n self.best_districts.append(self.district_population[index])\r\n self.best_costs.append(self.cost_populations[index])\r\n else:\r\n self.worst_districts.append(self.district_population[index])\r\n \r\n del self.cost_populations[index]\r\n del self.district_population[index]","def _GetEpiOrder(self):\n self.epi_series.sort()\n for series in self.epi_series:\n self.GetEpiAcqTimes(series)\n self.AssignEpiNames()","def get_Pre_Succ(I):\n #Docs = I.docs\n #Docs_id = Docs.keys()\n Docs = I.getIndex().all_ids_\n Docs_id = [ int(float(k)) for k in Docs] \n N_pgs = len(Docs_id)\n Index_P = { id:idx for idx,id in enumerate(Docs_id)}\n Counter_Index_P = { idx:id for idx,id in enumerate(Docs_id)}\n \n print \"\\nBuilding Pi...\"\n Succ = { Index_P[p]:(I.getLinksForDoc(p),len(I.getLinksForDoc(p))) for p in Docs_id }\n P = {}\n for e in Succ:\n succ_e,l_e = Succ[e]\n for s in succ_e: \n if Index_P.get(s,\"Unknown_Doc_id\") not in P:\n P[Index_P.get(s,\"Unknown_Doc_id\")] = set()\n P[Index_P.get(s,\"Unknown_Doc_id\")].add(e) \n \n return P,Succ,Index_P,Counter_Index_P,N_pgs","def PGL_order(A):\n\n n = 1\n AA = PGL_repn(A)\n B = copy(AA)\n while B[0][0] != B[1][1] or B[0][1] != 0 or B[1][0] != 0:\n n = n + 1\n B = AA*B\n\n return n","def custom_sort(arr):\n pass"],"string":"[\n \"def _sort(self):\\n self.rows.sort(key=lambda x: (x['PERC1'], x['EQ'], x['PASS'], x['W2']),\\n reverse=True)\\n\\n rank = 0\\n prev_perc = 0\\n prev_rank = 0\\n for row in self.rows:\\n if row[\\\"NR\\\"] == 0:\\n # Something has already populated NR as 0 - so we set rank as\\n # 0 too\\n row['_RANK'] = 0\\n row['_NR'] = 0\\n continue\\n\\n # Increment our count\\n rank += 1\\n if row['PERC1'] == prev_perc:\\n row['NR'] = \\\"\\\"\\n row['_NR'] = prev_rank # I.e. joint 6th will be 6 here\\n row['_RANK'] = rank # I.e. joint 6th could be 7, or 8 etc. here\\n else:\\n row['NR'] = rank\\n row['_NR'] = rank\\n row['_RANK'] = rank\\n prev_perc = row['PERC1']\\n prev_rank = rank\",\n \"def rank_drawr_property(final_spreadsheet_df, pg_network_n1_names):\\n prop_spreadsheet_df = final_spreadsheet_df.loc[pg_network_n1_names]\\n prop_spreadsheet_df.iloc[:, :-1] = prop_spreadsheet_df.iloc[:, :-1].apply(\\n lambda x: (x - prop_spreadsheet_df['base']).sort_values(ascending=0).index.values)\\n prop_spreadsheet_df = prop_spreadsheet_df.drop('base', 1)\\n\\n return prop_spreadsheet_df\",\n \"def sort_table(table, sats_table):\",\n \"def sort_index(self):\\n def s(t):\\n return tuple(sorted(t, key=self.clade_order))\\n self.scf.index = self.scf.index.map(s)\\n self.scf.index.names = [s.split('_')[0] for s in self.scf.index[0]]\",\n \"def sort_priors(self):\\n return\",\n \"def order_ideal(self, gens):\",\n \"def sortby(self):\\n ...\",\n \"def data_sort(gdf,str):\\n gdf = gdf.sort_values(by = [str])\\n \\n return gdf\",\n \"def sort(self):\\n for i in range(self.num):\\n for j in range(i,0,-1):\\n if self.genepool[0][j] < self.genepool[0][j-1]:\\n self.genepool[0][j], self.genepool[0][j-1] = self.genepool[0][j-1], self.genepool[0][j]\\n else:\\n break\\n for i in range(self.num):\\n for j in range(i,0,-1):\\n if self.genepool[1][j] < self.genepool[1][j-1]:\\n self.genepool[1][j], self.genepool[1][j-1] = self.genepool[1][j-1], self.genepool[1][j]\\n else:\\n break\",\n \"def oldsortslice(self):\\n ...\",\n \"def __get_score_ordered(scores, idx):\\t\\n\\treturn [x[1][idx] for x in sorted(scores.items())]\",\n \"def sort_by_idxs(self, idx_order):\\n self.Nx = [self.Nx[idx] for idx in idx_order]\\n self.dictionary = h.dictionary.Dictionary(\\n [self.dictionary.tokens[idx] for idx in idx_order])\\n\\n # We are no longer sorted according to unigram frequencies.\\n self.sorted = False\",\n \"def part_build_order(self):\\n priority = []\\n for geo_item in self.build_order:\\n if geo_item in self.parts:\\n priority += [geo_item]\\n return priority\",\n \"def reorder_bgc_data(df):\\n st_col_list = ['time','lat','lon','depth','year','month','week','dayofyear','float_id','cycle']\\n st_cols =df[st_col_list]\\n non_st_cols = df.drop(st_col_list, axis=1)\\n reorder_df = pd.concat([st_cols, non_st_cols], axis=1, sort=False)\\n \\n sci_col_list = [\\\"SCIENTIFIC_CALIB_COEFFICIENT\\\",\\\"SCIENTIFIC_CALIB_COMMENT\\\",\\\"SCIENTIFIC_CALIB_DATE\\\",\\\"SCIENTIFIC_CALIB_EQUATION\\\"]\\n sci_cols =reorder_df[sci_col_list]\\n non_sci_cols = reorder_df.drop(sci_col_list, axis=1)\\n neworder_df = pd.concat([non_sci_cols,sci_cols], axis=1, sort=False)\\n return neworder_df\",\n \"def sort_key(self):\\n ...\",\n \"def renumber_cells_ordering(self):\\n Nactive = sum(~self.cells['deleted'])\\n return np.argsort( self.cells['deleted'],kind='mergesort')[:Nactive]\",\n \"def nat_sort(x, df):\\n unordered = df.swing_drop.tolist()\\n reordered = natsorted(unordered, alg=ns.IGNORECASE)\\n return reordered.index(x)\",\n \"def set_trec_order(self):\\n for k in self._run:\\n self._run[k].sort(key=lambda x:(x.get_score(),x.get_doc()),reverse=True)\\n for r in self._run[k]:\\n print r.get_str()\",\n \"def sort(self):\\n \\n ct=[]\\n rt=[]\\n wr=[]\\n # search for tags that aren't in the right position\\n for i in range(len(self.contigs)):\\n c = self.contigs[i]\\n if c.wa:\\n if not self.wa:\\n self.wa=[]\\n self.wa.extend(c.wa)\\n if c.ct:\\n newcts=[ct_tag for ct_tag in c.ct if ct_tag.name!=c.name]\\n map(self.contigs[i].ct.remove,newcts)\\n ct.extend(newcts)\\n for j in range(len(c.reads)):\\n r = c.reads[j]\\n if r.rt:\\n newrts=[rt_tag for rt_tag in r.rt if rt_tag.name!=r.rd.name]\\n map(self.contigs[i].reads[j].rt.remove,newrts)\\n rt.extend(newrts)\\n if r.wr:\\n newwrs=[wr_tag for wr_tag in r.wr if wr_tag.name!=r.rd.name]\\n map(self.contigs[i].reads[j].wr.remove,newwrs)\\n wr.extend(newwrs)\\n # now sort them into their proper place\\n for i in range(len(self.contigs)):\\n c = self.contigs[i]\\n for ct_tag in ct:\\n if ct_tag.name==c.name:\\n if self.contigs[i].ct is None:\\n self.contigs[i].ct=[]\\n self.contigs[i].ct.append(ct_tag)\\n if rt or wr:\\n for j in range(len(c.reads)):\\n r = c.reads[j]\\n for rt_tag in rt:\\n if rt_tag.name==r.rd.name:\\n if self.contigs[i].reads[j].rt is None:\\n self.contigs[i].reads[j].rt=[]\\n self.contigs[i].reads[j].rt.append(rt_tag)\\n for wr_tag in wr:\\n if wr_tag.name==r.rd.name:\\n if self.contigs[i].reads[j].wr is None:\\n self.contigs[i].reads[j].wr=[]\\n self.contigs[i].reads[j].wr.append(wr_tag)\",\n \"def sort():\\n return -1\",\n \"def sort(self):\\n sort_key = self.data.chromosome.apply(sorter_chrom)\\n self.data = (\\n self.data.assign(_sort_key_=sort_key)\\n .sort_values(by=[\\\"_sort_key_\\\", \\\"start\\\", \\\"end\\\"], kind=\\\"mergesort\\\")\\n .drop(\\\"_sort_key_\\\", axis=1)\\n .reset_index(drop=True)\\n )\",\n \"def sort(self):\\n for i in range(self.num):\\n for j in range(i,0,-1):\\n if self.genepool[0][j].fitness < self.genepool[0][j-1].fitness:\\n self.genepool[0][j], self.genepool[0][j-1] = self.genepool[0][j-1], self.genepool[0][j]\\n else:\\n break\\n for i in range(self.num):\\n for j in range(i,0,-1):\\n if self.genepool[1][j].fitness < self.genepool[1][j-1].fitness:\\n self.genepool[1][j], self.genepool[1][j-1] = self.genepool[1][j-1], self.genepool[1][j]\\n else:\\n break\",\n \"def sort(self, A, index, p, r, rc_arr):\\n\\n if p < r:\\n q = (p + r) // 2\\n\\n self.sort(A, index, p, q, rc_arr)\\n self.sort(A, index, q + 1, r, rc_arr)\\n self.merge(A, index, p, q, r, rc_arr)\",\n \"def reorder( self ):\\n self.sorted.sort(self.compareFunction)\",\n \"def sort_processes(ps_df: pd.DataFrame, user_sort: list) -> pd.DataFrame:\\n result_df = ps_df.sort_values(by=user_sort, ascending=True)\\n return result_df\",\n \"def sorting_generator(G,desired_numberofcolumns):\\n dimension = len(G)\\n\\n if dimension == desired_numberofcolumns:\\n return G , None\\n indexlist = np.argsort(np.linalg.norm( G ,axis=0 ,ord = None))\\n sortedG = (G)[:,indexlist]\\n G_untouched = sortedG[: , - (desired_numberofcolumns - dimension ): ]\\n G_reduced = sortedG[: , : -(desired_numberofcolumns - dimension ) ]\\n \\n return G_reduced , G_untouched\",\n \"def resort_couplings(J,sortIx):\\n return\",\n \"def SortL(L, g):\\n for i in range(len(L)):\\n L[i, 0] = i\\n L[i, 1] = alpha[i]\\n L[i, 2] = y_train[i]*g[i]\\n L = sorted(L, key=itemgetter(2))\\n L = np.array(L)\\n return L\",\n \"def ordering(self):\\n value = []\\n for i in self:\\n if isinstance(i, PQ):\\n value.extend(i.ordering())\\n else:\\n value.append(i)\\n\\n return value\",\n \"def analyse_and_sort(self, df):\\n if (type(df) is pd.Series):\\n df = df.to_frame(\\\"score\\\")\\n elif (type(df) is pd.DataFrame):\\n df.columns = [\\\"score\\\"]\\n df = self._filter(df)\\n df = self._argrelmax(df)\\n df = self._drop_close_extrema(df) # by = [deb1[0]]\\n return df.sort_values(by=[\\\"score\\\"])[::-1]\",\n \"def continuousOrder(snap):\\n idx = computeIncreasingGridIndex(snap)\\n idxIdx = idx.argsort()\\n \\n new = snap.copy()\\n\\n for i, ind in enumerate(idxIdx):\\n new[i] = snap[ind]\\n continue\\n \\n return new\",\n \"def pdc_pivot(dh: DataHandler):\\n df = dh.get(\\\"o_prices\\\")\\n\\n df = df.reset_index().pivot(index=\\\"t\\\", columns=\\\"r\\\")\\n\\n for col in df.columns:\\n df[col] = sorted(df[col])\\n\\n df = df.reset_index(drop=True)\\n return df\",\n \"def _sort(self):\\n self.population.sort()\\n self.population.reverse()\",\n \"def sort_challengers_by_points(self):\\n if not self.isOrdered:\\n order = []\\n for k, i in self.scores.items():\\n order.append((i, k))\\n order.sort()\\n\\n nb = len(self.challengers)\\n for i, d in enumerate(order):\\n self.challengers[nb - i - 1] = d[1]\\n self.isOrdered = True\\n return self.challengers\",\n \"def get_sorted_parties():\\n return list(dfSeatsPerPartyBy2ndVotes.sort_values(by=[\\\"party\\\"])[\\\"party\\\"])\",\n \"def sort_data(df, col_order=[\\\"id\\\", 'event_name', 'specialty', 'plan_type']):\\n df.sort_values(col_order, inplace = True)\\n df.reset_index(drop=1, inplace=True)\\n return df\",\n \"def _cmplx_sort(p):\\n indx = cupy.argsort(cupy.abs(p))\\n return cupy.take(p, indx, 0), indx\",\n \"def sort_restos(filtered_table):\\n\\tdf = pd.DataFrame(filtered_table).T\\n\\tdf = df.sort(columns=columns['time_to_resto'])\\n\\n\\treturn df.index\",\n \"def part_build_order(self) -> List[str]:\\n priority = []\\n for geo_item in self.build_order:\\n if geo_item in self.parts and isinstance(self.parts[geo_item], Polygon):\\n priority += [geo_item]\\n return priority\",\n \"def sort_results(self):\\n pass\",\n \"def reversesort(self):\\n ...\",\n \"def sortColors(self, nums: List[int]) -> None:\\n\\n def quick_sort(ary, gte_idx, lte_idx) -> None:\\n\\n # 재귀 탈출조건\\n if lte_idx - gte_idx < 1:\\n return\\n\\n # 임의의 위치를 pivot으로 지정 (여기선 가운데 값)\\n init_pivot_idx = (gte_idx + lte_idx) // 2\\n\\n # print(\\\"test:\\\", [str(p) if gte_idx <= p_idx <= lte_idx else \\\"_\\\" for p_idx, p in enumerate(ary)])\\n # pivot 값을 맨 앞의 값과 swap한다 (순차적으로 읽으면서 pivot과 비교할거니까)\\n ary[gte_idx], ary[init_pivot_idx] = ary[init_pivot_idx], ary[gte_idx]\\n\\n # gte_idx+1부터 차례로 읽으면서 pivot보다 작은 값이 있으면\\n # 읽은 범위 내의 pivot보다 큰 값 중 맨 앞의 것과 swap해준다\\n bigger_idx = gte_idx + 1\\n for i in range(gte_idx + 1, lte_idx + 1):\\n # 맨 앞의 pivot과 비교\\n if ary[i] < ary[gte_idx]:\\n ary[i], ary[bigger_idx] = ary[bigger_idx], ary[i]\\n bigger_idx += 1\\n # print(\\\"test:\\\", [str(p) if gte_idx <= p_idx <= lte_idx else \\\"_\\\" for p_idx, p in enumerate(ary)])\\n\\n # 맨 앞에 있던 pivot을 pivot보다 큰 범위의 바로 앞의 값과 swap\\n ary[gte_idx], ary[bigger_idx - 1] = ary[bigger_idx - 1], ary[gte_idx]\\n # print(\\\"test:\\\", [str(p) if gte_idx <= p_idx <= lte_idx else \\\"_\\\" for p_idx, p in enumerate(ary)])\\n\\n # recursion으로 좌우 분할정복\\n pivot_idx = bigger_idx - 1\\n quick_sort(ary, gte_idx, pivot_idx - 1)\\n quick_sort(ary, pivot_idx + 1, lte_idx)\\n\\n quick_sort(nums, 0, len(nums) - 1)\",\n \"def sort(self):\\n\\n # momentarily convert into numpy, to take advantage of their easy \\n # sorting.\\n top_indices = np.argsort([-n for n in self.Nx])\\n self.Nx = [self.Nx[i] for i in top_indices]\\n self.dictionary = h.dictionary.Dictionary([\\n self.dictionary.tokens[i] for i in top_indices])\\n\\n self.sorted = True\\n\\n return top_indices\",\n \"def sorted(self): \\n pass\",\n \"def _sort_dataframe(self, dataframe):\\r\\n print('Not allowed')\",\n \"def _sort(self, row):\\n if not self._head:\\n self._head = self._create_head(row)\\n if self._args.head:\\n return row\\n\\n if 'key' not in self._state:\\n self._state['key'] = self._replace_fields(self._args.key)\\n\\n r = list(map(self._convert, row))\\n self._sorting_insert(self._result, r, key=lambda r: eval(self._state['key']))\",\n \"def toposort(prereqs_d):\\r\\n\\r\\n# all1 = set(prereqs_d.keys())\\r\\n# all2 = set()\\r\\n# for x, y in prereqs_d.items():\\r\\n# all2.update(y)\\r\\n# print all1.difference(all2)\\r\\n\\r\\n seq = []\\r\\n done = set()\\r\\n postreqs_d = {}\\r\\n for x, prereqs in prereqs_d.items():\\r\\n for prereq in prereqs:\\r\\n postreqs_d.setdefault(prereq, set()).add(x)\\r\\n next = set([k for k in prereqs_d if not prereqs_d[k]])\\r\\n while next:\\r\\n bases = next\\r\\n next = set()\\r\\n for x in bases:\\r\\n done.add(x)\\r\\n seq.append(x)\\r\\n for x in bases:\\r\\n for postreq in postreqs_d.get(x, []):\\r\\n if not prereqs_d[postreq].difference(done):\\r\\n next.add(postreq)\\r\\n if len(prereqs_d) != len(seq):\\r\\n raise Exception(\\\"Cannot sort topologically: there might be cycles, \\\"\\r\\n \\\"prereqs_d does not have a key for each element or \\\"\\r\\n \\\"some orderings contain invalid elements.\\\")\\r\\n return seq\",\n \"def sort_gefs_frame(frame):\\n if frame is None:\\n return frame\\n else:\\n return pd.DataFrame(np.sort(frame), index=frame.index)\",\n \"def calc_ply_order(constraints, targets):\\r\\n if constraints.sym:\\r\\n ply_order = np.arange(targets.n_plies // 2 + targets.n_plies % 2)\\r\\n return ply_order\\r\\n\\r\\n order_before_sorting = np.arange(targets.n_plies)\\r\\n ply_order = np.zeros((targets.n_plies,), int)\\r\\n ply_order[0::2] = order_before_sorting[\\r\\n :targets.n_plies // 2 + targets.n_plies % 2]\\r\\n ply_order[1::2] = order_before_sorting[\\r\\n targets.n_plies // 2 + targets.n_plies % 2:][::-1]\\r\\n return ply_order\",\n \"def sort(self, Ncol, order):\\n self.emit(SIGNAL(\\\"layoutAboutToBeChanged()\\\"))\\n self.arraydata = sorted(self.arraydata, key=operator.itemgetter(Ncol)) \\n if order == Qt.DescendingOrder:\\n self.arraydata.reverse()\\n self.emit(SIGNAL(\\\"layoutChanged()\\\"))\",\n \"def smartcotagsort(prefix, gwascotag, column='Cotagging', ascending=False,\\n title=None):\\n picklefile = '%s_%s.pickle' % (prefix, ''.join(column.split()))\\n if os.path.isfile(picklefile):\\n with open(picklefile, 'rb') as F:\\n df, beforetail = pickle.load(F)\\n else:\\n print('Sorting File based on %s \\\"clumping\\\"...' % column)\\n gwascotag.loc[:, 'm_size'] = norm(abs(gwascotag.slope), 10, 150)\\n grouped = gwascotag.sort_values(by=column, ascending=ascending).groupby(\\n column, as_index=False, sort=False).first()\\n sorteddf = grouped.sort_values(by=column, ascending=ascending)\\n tail = gwascotag[~gwascotag.snp.isin(sorteddf.snp)]\\n beforetail = sorteddf.shape[0]\\n df = sorteddf.copy()\\n if not tail.empty:\\n df = df.append(tail.sample(frac=1), ignore_index=True)\\n df = df.reset_index(drop=True)\\n df['index'] = df.index.tolist()\\n with open(picklefile, 'wb') as F:\\n pickle.dump((df, beforetail), F)\\n idx = df.dropna(subset=['beta']).index.tolist()\\n causals = df.loc[idx, :]\\n size = df.m_size\\n f, ax = plt.subplots()\\n df.plot.scatter(x='pos', y='index', ax=ax, label=column)\\n if not causals.empty:\\n causals.plot.scatter(x='pos', y='index', marker='*', c='k', ax=ax,\\n s=size[idx].values, label='Causals')\\n if title is not None:\\n plt.title(title)\\n plt.tight_layout()\\n plt.savefig('%s_%s.pdf' % (prefix, '_'.join(column.split())))\\n plt.close()\\n return df, beforetail\",\n \"def _sort_ns(self):\\n n = []\\n for layer in self.structure:\\n n.append(layer.get_index())\\n n = np.asarray(n)\\n return n\",\n \"def sortdb():\\n return sorted(donor_db.items(), key=sumdbkey, reverse=True)\",\n \"def sort(self, Ncol, order):\\n self.emit(SIGNAL(\\\"layoutAboutToBeChanged()\\\"))\\n self.arraydata = sorted(self.arraydata, key=operator.itemgetter(Ncol)) \\n if order != Qt.DescendingOrder:\\n self.arraydata.reverse()\\n self.emit(SIGNAL(\\\"layoutChanged()\\\"))\",\n \"def sort_column_type(sorted_subgroups):\\n new_document_list = []\\n for page in sorted_subgroups:\\n if page[0]:\\n if page[1]:\\n if page[2]:\\n if page[1][0][0]['bbox'][1] < page[2][0][0]['bbox'][1]:\\n new_document_list.append([page[0], page[1], page[2]])\\n else:\\n new_document_list.append([page[0], page[2], page[1]])\\n else:\\n new_document_list.append([page[0], page[1]])\\n else:\\n if page[2]:\\n new_document_list.append([page[0], page[2]])\\n else:\\n new_document_list.append([page[0]])\\n else:\\n if page[1]:\\n if page[2]:\\n if page[1][0][0]['bbox'][1] < page[2][0][0]['bbox'][1]:\\n new_document_list.append([page[1], page[2]])\\n else:\\n new_document_list.append([page[2], page[1]])\\n else:\\n new_document_list.append([page[1]])\\n else:\\n if page[2]:\\n new_document_list.append([page[2]])\\n return new_document_list\",\n \"def sort(self, trans, query, ascending, column_name=None):\\n return grids.GridColumn.sort(self, trans, query, ascending, column_name=\\\"history_id\\\")\",\n \"def get_order(order, gt_idx_v):\\n o = np.tile(order, (gt_idx_v.shape[0],1))\\n g = np.expand_dims(gt_idx_v, 1)\\n o = o - g\\n l, c = np.where(o==0)\\n return c # order[c[0]] = gt_idx_v[0]\",\n \"def _sort_impact(sv_ndx, impact):\\n\\n if impact.ndim == 2:\\n impact = np.sum(impact, axis=1)\\n impact_list = zip(sv_ndx, impact)\\n impact_list = sorted(sorted(impact_list, key=lambda x: x[0]), key=lambda x: abs(x[1]), reverse=True)\\n\\n sv_ndx, impact = zip(*impact_list)\\n sv_ndx = np.array(sv_ndx)\\n return sv_ndx, impact\",\n \"def order_channels_by_distance(reference, channels, geom):\\n coord_main = geom[reference]\\n coord_others = geom[channels]\\n idx = np.argsort(np.sum(np.square(coord_others - coord_main), axis=1))\\n\\n return channels[idx], idx\",\n \"def _sort_dataframe(self, dataframe):\\r\\n columns = list(dataframe.columns)\\r\\n columns.sort()\\r\\n dataframe = dataframe[columns]\\r\\n return dataframe\",\n \"def sort(self):\\r\\n self.candidates.sort(key=self.sortFitness)\\r\\n return\",\n \"def sort_list_by_president_order(pronoun_proportion_list):\\n return sorted(pronoun_proportion_list, key=lambda (k,d,v): (d,k,v))\",\n \"def parse_sort_clump(fn, allsnps):\\n # make sure allsnps is a series\\n allsnps = pd.Series(allsnps)\\n try:\\n df = pd.read_table(fn, delim_whitespace=True)\\n except FileNotFoundError:\\n spl = fn.split('.')\\n if spl[0] == '':\\n idx = 1\\n else:\\n idx = 0\\n fn = '.'.join(np.array(spl)[[idx, 1 + idx, -1]])\\n if idx == 1:\\n fn = '.%s' % fn\\n df = pd.read_table(fn, delim_whitespace=True)\\n SNPs = df.loc[:, 'SP2']\\n tail = [x.split('(')[0] for y in SNPs for x in y.split(',') if x.split('(')[\\n 0] != 'NONE']\\n full = pd.DataFrame(df.SNP.tolist() + tail, columns=['SNP'])\\n full = full[full.SNP.isin(allsnps)]\\n rest = allsnps[~allsnps.isin(full.SNP)]\\n df = pd.concat((full.SNP, rest)).reset_index(drop=False)\\n df.rename(columns={'index': 'Index'}, inplace=True)\\n return df\",\n \"def calculate_points_sorted(self):\\n self._scrabble_word_point_dict_sorted = dict(sorted(\\n self.calculate_points().items(), key=lambda x: x[1], reverse=True))\\n return self._scrabble_word_point_dict_sorted\",\n \"def order_field(pivData):\\n def inner(Ax, Ay, Bx, By):\\n \\\"\\\"\\\"\\n define inner product between two matrices\\n \\\"\\\"\\\"\\n return (Ax*Bx + Ay*By) / (Ax**2+Ay**2)**0.5 / (Bx**2+By**2)**0.5\\n col = len(pivData.x.drop_duplicates())\\n row = len(pivData.y.drop_duplicates())\\n u = np.array(pivData.u).reshape((row, col))\\n v = np.array(pivData.v).reshape((row, col))\\n u1 = np.roll(u, -1, axis=0) # up\\n v1 = np.roll(v, -1, axis=0) # up\\n u2 = np.roll(u, 1, axis=0) # down\\n v2 = np.roll(v, 1, axis=0) # down\\n u3 = np.roll(u, 1, axis=1) # right\\n v3 = np.roll(v, 1, axis=1) # right\\n u4 = np.roll(u, -1, axis=1) # left\\n v4 = np.roll(v, -1, axis=1) # left\\n \\n # do inner products with original matrix\\n I1 = inner(u, v, u1, v1)\\n I2 = inner(u, v, u2, v2)\\n I3 = inner(u, v, u3, v3)\\n I4 = inner(u, v, u4, v4)\\n \\n # average the products\\n order = (I1 + I2 + I3 + I4) / 4\\n \\n return order\",\n \"def _sort_ds(self):\\n d = []\\n for layer in self.structure:\\n if (layer.type == 'Layer' or layer.type == 'Substrate'):\\n d.append(layer.thickness)\\n d.insert(0, self.structure[0].thickness)\\n d.append(self.structure[-1].thickness)\\n d = np.asarray(d)\\n return d\",\n \"def data_for_sorting():\\n return RaggedArray([[1, 0], [2, 0], [0, 0]])\",\n \"def sortFastND(fitnesses, k, probabilitiesForObjectives, first_front_only=False):\\n if k == 0:\\n return []\\n\\n N = len(fitnesses)\\n pareto_fronts = []\\n\\n pareto_fronts.append([])\\n pareto_sorted = 0\\n dominating_fits = [0] * N\\n dominated_fits = [list() for i in range(N)]\\n\\n # Rank first Pareto front\\n for i, fit_i in enumerate(fitnesses):\\n for j, fit_j in enumerate(fitnesses[i+1:], i+1):\\n if isStochasticallyDominated(fit_i, fit_j,probabilitiesForObjectives):\\n dominating_fits[i] += 1\\n dominated_fits[j].append(i)\\n elif isStochasticallyDominated(fit_j, fit_i,probabilitiesForObjectives):\\n dominating_fits[j] += 1\\n dominated_fits[i].append(j)\\n if dominating_fits[i] == 0:\\n pareto_fronts[-1].append(i)\\n pareto_sorted += 1\\n\\n # Rank the next front until all individuals are sorted or the given\\n # number of individual are sorted\\n if not first_front_only:\\n k = min(N, k)\\n while pareto_sorted < k:\\n pareto_fronts.append([])\\n for indice_p in pareto_fronts[-2]:\\n for indice_d in dominated_fits[indice_p]:\\n dominating_fits[indice_d] -= 1\\n if dominating_fits[indice_d] == 0:\\n pareto_fronts[-1].append(indice_d)\\n pareto_sorted += 1\\n\\n ranks = {}\\n for i, front in enumerate(pareto_fronts):\\n for j, idx in enumerate(front):\\n front[j] = fitnesses[idx]\\n ranks[fitnesses[idx]] = i\\n\\n return pareto_fronts, ranks\",\n \"def sort_docs_by_price(self, reverse=False):\\n self.documents_predicted_relevant.sort(key=lambda doc: doc.price, reverse=reverse)\",\n \"def sort_final(y):\\n with open(selected_pb, 'w') as outpb:\\n pb = []\\n for pr in y:\\n pb.append({\\n \\\"active\\\": pr[\\\"active\\\"],\\n \\\"asn\\\": pr[\\\"asn\\\"],\\n \\\"countrycode\\\": pr[\\\"countrycode\\\"],\\n \\\"id\\\": pr[\\\"id\\\"],\\n \\\"statecode\\\": pr[\\\"statecode\\\"],\\n \\\"meta\\\": pr[\\\"meta\\\"],\\n \\\"dist\\\": pr[\\\"dist\\\"]\\n })\\n datap = json.dumps(pb)\\n outpb.write(datap)\\n with open(selected_pb, 'r') as f:\\n selected_dist = json.load(f)\\n return selected_dist\",\n \"def find_order(data, ending = '7day_avg', fn = np.mean):\\n subset = data[[i for i in data.columns if i.endswith(ending)]]\\n df = pd.DataFrame(data = [subset.columns.str[:12].tolist(),[fn(data.iloc[:,i]) for i in range(subset.shape[1])]],\\n index = ['geoid','val']).T\\n df = df.sort_values(by='val', ascending=False)\\n df.index = range(df.shape[0])\\n df['plot_group'] = [np.floor(i/3) + 1 for i in df.index]\\n df['order_in_group'] = [i % 3 for i in df.index]\\n \\n return df\",\n \"def Wsort_theo(D, k):\\n\\ta1b = k[\\\"A1B1\\\"]\\n\\tba1 = k[\\\"B1A1\\\"]\\n\\tba2 = k[\\\"C1A1\\\"]\\n\\tbc = k[\\\"B1C1\\\"]\\n\\t##\\n\\tASS = ASS_theo(D,k)\\n\\ttSS = SSt_theo(D,k)\\n\\t##\\n\\teps = a1b*ba2*(1 + D)*(ba1 + 2*bc + ba2*D)\\n\\t# zet = a1b*(ba1 - ba2)*ba2*(D-1)*(D+1)\\n\\tzet = a1b*(ba1 + ba2)*ba2*(D-1)*(D+1)\\n\\teta = 2*a1b*(ba1 + 2*bc + ba2*D)\\n\\t# the = 2*a1b*(ba1 - ba2)*(D-1)\\n\\tthe = 2*a1b*(ba1 + ba2)*(D-1)\\n\\t##\\n\\teps += zet*ASS\\n\\teta += the*ASS\\n\\tzet *= (0.5-ASS)\\n\\tthe *= (0.5-ASS)\\n\\t##\\n\\t# Wsort = tSS*(zet/the+(eps/eta-zet/the)*np.log((np.exp(1))+the/eta)/(1+the/eta))\\n\\tWsort = 0.5*ba2*(1+D)*tSS * np.log(D) \\n\\treturn -Wsort *2/(D+1)\",\n \"def sort_reads(self): \\n if not self.sampling:\\n self.convert_to_array()\\n self.reads = self.reads[self.reads[:,0].argsort()]\",\n \"def sorted_gnames():\\n return sorted(group_names.keys())\",\n \"def reorder_cols(df):\\n # print(df.columns)\\n req_order = [df.columns.tolist()[-1]] + df.columns.tolist()[:-1]\\n # print(req_order)\\n df = df.loc[:, req_order]\\n df = df.sort_values(by=['participant_id'], ignore_index=True)\\n return df\",\n \"def _order_fc_accordingto_networkname(sel, data):\\n colname = list(data.columns)\\n fcname = [name.split(' ')[1] if len(name.split(' '))\\n > 1 else name.split(' ')[0] for name in colname]\\n # sorted by the first item of each str\\n idx = [i for i, v in sorted(enumerate(fcname), key=lambda x:x[1])]\\n sorted_colname = [colname[id] for id in idx]\\n sorted_data = data[sorted_colname]\\n return sorted_data\",\n \"def __sort_orders_by_price(self):\\n self.orders = sorted(self.orders, key=lambda o: o.price, reverse=True)\",\n \"def grouping(data,dis):\\n cluRe = []\\n for i in range(len(data)):\\n cluRe.append(np.argsort(dis[i])[0])\\n \\n return np.asarray(cluRe)\",\n \"def sort_partitions():\\n usb_partitions = usb_partition_table()\\n sorted_partitions = sorted(usb_partitions.items(), key=lambda x: x[1])\\n return sorted_partitions\",\n \"def gather_referring_orders (gdbval):\\n# TODO: Somehow also note speculative references and attributes in\\n# general\\n vec = gdbval[\\\"referring\\\"]\\n return [int(i[\\\"referring\\\"][\\\"order\\\"]) for i in vec_iter(vec)]\",\n \"def sort(self, quant=None):\\n if quant is None: # sort bei weight\\n self.__sortlist = [key for key, values in sorted(self.__quantile.items(), key=lambda items: sum((10^quantille * count for quantille, count in enumerate(items[1].values()))))]\\n elif isinstance(quant, int):\\n self.__sortlist = [key for key, values in sorted(self.__quantile.items(), key=lambda items: items[1][quant])]\",\n \"def _sort_compounds(self):\\n self.sorted_molecules = sorted(self.values(), key=operator.attrgetter('criterion'))\",\n \"def sort(self): # sort all entries to make room for new ones, determine best and worst\\n ns = self.num_stored.value\\n ys = np.asarray(self.ys[:ns])\\n yi = ys.argsort()\\n sortRuns = []\\n for i in range(len(yi)):\\n y = ys[yi[i]]\\n xs = self.get_x(yi[i])\\n sortRuns.append((y, xs))\\n numStored = min(len(sortRuns),int(0.9*self.capacity)) # keep 90% best \\n for i in range(numStored):\\n self.replace(i, sortRuns[i][0], sortRuns[i][1])\\n self.num_sorted.value = numStored \\n self.num_stored.value = numStored \\n return numStored\",\n \"def transform_ordering(new_document_list):\\n doc_list = []\\n for page in new_document_list:\\n # print(\\\"PAGE:\\\")\\n page_list = []\\n for col_type in page:\\n # print(\\\"\\\\tCOL_TYPE:\\\")\\n for column in col_type:\\n # print(\\\"\\\\t\\\\tCOLUMN:\\\")\\n for group in column:\\n # print(\\\"\\\\t\\\\t\\\\t\\\" + str(group))\\n page_list.append(group)\\n doc_list.append(page_list)\\n return doc_list\",\n \"def sort_rows(self) -> list:\\r\\n\\r\\n # Sort Inner rows\\r\\n done_rows = []\\r\\n\\r\\n # Sort each row independently\\r\\n for r in self.rows:\\r\\n \\r\\n # Insertion Sort by x coordinate\\r\\n r = r[::-1] # reverse the list first to speed up sorting\\r\\n # this is faster because the list is\\r\\n # already partly reverse sorted\\r\\n \\r\\n sorted_row = []\\r\\n \\r\\n while r != []:\\r\\n\\r\\n # Take element from row\\r\\n el = r.pop()\\r\\n\\r\\n # Find where it belongs\\r\\n curr = 0\\r\\n while curr < len(sorted_row) and \\\\\\r\\n el.get_center()[0] > sorted_row[curr].get_center()[0]:\\r\\n \\r\\n curr += 1\\r\\n\\r\\n # Insert it there\\r\\n sorted_row.insert(curr, el)\\r\\n\\r\\n # collect sorted rows\\r\\n done_rows.append(sorted_row)\\r\\n\\r\\n\\r\\n # Sort Inter rows\\r\\n finished = []\\r\\n \\r\\n while done_rows != []:\\r\\n\\r\\n # Take out a row\\r\\n el = done_rows.pop()\\r\\n\\r\\n # Find where it belongs\\r\\n curr = 0\\r\\n while curr < len(finished) and \\\\\\r\\n (finished[curr][0].get_center()[1]\\r\\n + finished[curr][len(finished[curr]) - 1].get_center()[1]) \\\\\\r\\n / 2 < (el[0].get_center()[1]\\r\\n + el[len(el) - 1].get_center()[1]) / 2:\\r\\n curr += 1\\r\\n\\r\\n # Insert it there\\r\\n finished.insert(curr, el)\\r\\n\\r\\n\\r\\n # Set the sorted rows\\r\\n self.rows = finished\",\n \"def gnome_sort(items):\\n i = 0\\n n = len(items)\\n while i < n:\\n if i and items[i] < items[i-1]:\\n items[i], items[i-1] = items[i-1], items[i]\\n i -= 1\\n else:\\n i += 1\\n return items\",\n \"def _build_sort1_table(key_itime, keys_map, header_dict,\\n form, form_results, form_resultsi,\\n disp_dict, stress_dict, strain_dict, force_dict,\\n strain_energy_dict, gpstress_dict, log):\\n is_results = False\\n form_resultsi_subcase = []\\n #for key, value in header_dict.items():\\n #print(key, value)\\n # (isubcase, analysis_code, sort_method,\\n # count, ogs, superelement_adaptivity_index) = key\\n key_itime0 = key_itime[0]\\n key0 = key_itime0[0]\\n # (isubcase, analysis_code, sort_method,\\n # count, ogs, superelement_adaptivity_index, pval_step) = key\\n subcase_id_old = key0[0]\\n count_old = key0[3]\\n ogs_old = key0[4]\\n subtitle_old = key0[5]\\n subtitle_old, label_old, superelement_adaptivity_index_old, unused_pval_step_old = keys_map[key0]\\n del label_old\\n del superelement_adaptivity_index_old\\n\\n # now that we have the data built, we put it in the form\\n # in sorted order\\n #\\n # TODO: consider pval_step\\n for key, itime in key_itime:\\n # (isubcase, analysis_code, sort_method,\\n # count, ogs, superelement_adaptivity_index, pval_step) = key\\n #print('key =', key)\\n subcase_id = key[0]\\n count = key[3]\\n ogs = key[4]\\n #print('*ogs =', ogs)\\n #subtitle = key[4]\\n try:\\n subtitle, unused_label, superelement_adaptivity_index, unused_pval_step = keys_map[key]\\n except Exception:\\n subcase_id = subcase_id_old\\n subtitle = subtitle_old + '?'\\n superelement_adaptivity_index = '?'\\n raise\\n\\n #print('key =', key)\\n if subcase_id != subcase_id_old or subtitle != subtitle_old or ogs != ogs_old:\\n count_str = '' if count == 0 else ' ; opt_count=%s' % count_old\\n ogs_str = '' if ogs == 0 else '; OGS=%s' % ogs_old\\n subcase_str = 'Subcase %s; %s%s%s%s' % (\\n subcase_id_old, subtitle_old, superelement_adaptivity_index, count_str, ogs_str)\\n #print(subcase_str)\\n res = (\\n subcase_str.rstrip('; '),\\n None,\\n form_resultsi_subcase\\n )\\n form_resultsi.append(res)\\n form_resultsi_subcase = []\\n subcase_id_old = subcase_id\\n subtitle_old = subtitle\\n count_old = count\\n ogs_old = ogs\\n\\n\\n try:\\n header = header_dict[(key, itime)]\\n except KeyError: # this hits for strain energy\\n msg = 'Missing (key, itime) in header_dict\\\\n'\\n msg += ' key=%s\\\\n' % str(key)\\n\\n (subcase, analysis_code, sort_method,\\n count, ogs, superelement_adaptivity_index, pval_step) = key\\n msg += f' subcase={subcase}\\\\n'\\n msg += f' analysis_code={analysis_code}\\\\n'\\n msg += f' sort_method={sort_method}\\\\n'\\n msg += f' count={count}\\\\n'\\n msg += f' ogs={ogs}\\\\n'\\n msg += f' superelement_adaptivity_index={superelement_adaptivity_index!r}\\\\n'\\n msg += f' pval_step={pval_step!r}\\\\n'\\n\\n msg += ' itime=%s\\\\n' % itime\\n msg += ' %s\\\\n' % str((key, itime))\\n msg += 'Possible (key, time):\\\\n'\\n for keyi in header_dict:\\n msg += ' %s\\\\n' % str(keyi)\\n #print(msg.rstrip())\\n #print('expected = (%s, %r)\\\\n' % (str(key), itime))\\n log.error(msg.rstrip() + '\\\\n')\\n #self.log.error('expected = (%s, %r)\\\\n' % (str(key), itime))\\n continue\\n #raise KeyError(msg)\\n try:\\n header = header.strip()\\n except Exception:\\n print('header = %r' % header)\\n raise\\n\\n\\n form_outi = []\\n form_out = (header, None, form_outi)\\n disp_formi = disp_dict[(key, itime)]\\n stress_formi = stress_dict[(key, itime)]\\n strain_formi = strain_dict[(key, itime)]\\n force_formi = force_dict[(key, itime)]\\n strain_energy_formi = strain_energy_dict[(key, itime)]\\n gpstress_formi = gpstress_dict[(key, itime)]\\n if disp_formi:\\n form_outi += disp_formi\\n #form_outi.append(('Disp', None, disp_formi))\\n if stress_formi:\\n form_outi.append(('Stress', None, stress_formi))\\n is_results = True\\n if strain_formi:\\n form_outi.append(('Strain', None, strain_formi))\\n is_results = True\\n if force_formi:\\n form_outi.append(('Force', None, force_formi))\\n is_results = True\\n if strain_energy_formi:\\n form_outi.append(('Strain Energy', None, strain_energy_formi))\\n is_results = True\\n if gpstress_formi:\\n form_outi.append(('Grid Point Stresses', None, gpstress_formi))\\n is_results = True\\n\\n if form_outi:\\n is_results = True\\n form_resultsi_subcase.append(form_out)\\n #break\\n\\n #print(\\\"subcase_id = \\\", subcase_id)\\n if subcase_id:\\n count_str = '' if count == 0 else ' ; opt_count=%s' % count_old\\n ogs_str = '' if ogs == 0 else '; OGS=%s' % ogs_old\\n subcase_str = 'Subcase %s; %s%s%s' % (subcase_id, subtitle, count_str, ogs_str)\\n #print('*', subcase_str)\\n res = (\\n subcase_str.strip('; '),\\n None,\\n form_resultsi_subcase\\n )\\n form_resultsi.append(res)\\n assert len(form_out) > 0, form_out\\n form_resultsi_subcase = []\\n\\n if is_results:\\n form.append(form_results)\\n assert len(form_out) > 0, form_out\\n #print('formi =', formi)\\n #print('form_out =', form_out)\\n #print('form_resultsi =', form_resultsi)\\n #print('form_results =', form_results)\\n #print(form)\\n #if len(formi):\\n #form.append(form0)\\n #print(form)\\n #aa\\n #print('form', form)\\n #print('form_results =', form_results)\\n return form\",\n \"def sort_decls(self):\\n\\n #import simplecssbuilder\\n #SHORTHAND_REL = simplecssbuilder.SHORTHAND_REL\\n\\n def decl_key(decl):\\n \\\"\\\"\\\"key for sorting declarations\\\"\\\"\\\"\\n prop = decl.split(':')[0] # get property name\\n if str(prop) in SHORTHAND_REL_inv:\\n return SHORTHAND_REL_inv[str(prop)]\\n else:\\n return str(prop)\\n\\n def sort_decls_clique(clique):\\n \\\"\\\"\\\"Sort the declarations in clique\\\"\\\"\\\"\\n (_,ps) = clique\\n ps.sort(key=decl_key)\\n\\n # compute the inverse of SHORTHAND_REL\\n SHORTHAND_REL_inv = dict()\\n for k,vs in SHORTHAND_REL.iteritems():\\n for v in vs:\\n SHORTHAND_REL_inv[v] = k\\n\\n #print 'PRINTING CLIQUES'\\n for clique in self.cliques:\\n #print clique\\n sort_decls_clique(clique)\\n #print clique\",\n \"def sortRegioni(tupla):\\n\\t\\n\\treturn int(tupla[0])\",\n \"def selection_sort(self, data):\\n for i in range(len(data)-1, 0, -1):\\n i_max = 0\\n for j in range(1, i+1):\\n if data[j] > data[i_max]:\\n i_max = j\\n tmp = data[i]\\n data[i] = data[i_max]\\n data[i_max] = tmp\\n print \\\"pass\\\", i, data\",\n \"def order_output(self):\\n self.output = self.output[self.cols]\",\n \"def dmc_order(self):\\n return sorted(self.lookup_table, key=lambda clr: int(clr.id) if clr.id.isdigit() else 0)\",\n \"def recommendation_ranking(self):\\n iu = self.final_recommendation_score_matrix()\\n new_iu = []\\n for row in iu:\\n li = []\\n temp = row\\n if self.product != \\\"dist\\\":\\n temp = -np.sort(-temp)\\n for element in row:\\n li.append(binary_search_opp(temp,element)+1) \\n else:\\n temp = np.sort(temp)\\n for element in row:\\n li.append(np.searchsorted(temp,element)+1)\\n new_iu.append(li)\\n return np.array(new_iu)\",\n \"def sort(self):\\r\\n\\t\\treturn sorted(self.sample)\",\n \"def sort_weight(self):\\n self._elements = list(\\n _[-1] for _ in sorted((e.weight, e.value, e) for e in self)\\n )\",\n \"def getorder(columns, langs):\\n order = []\\n for lang in langs:\\n i = 0\\n for col in columns:\\n if col == lang:\\n order.append(i)\\n i += 1\\n if len(order) != len(langs):\\n print(\\\"Either missing a language or have a duplicate\\\\n\\\")\\n return order\",\n \"def sort_values(self):\\r\\n for loopindex in range(0, self.population_size):\\r\\n index = self.cost_populations.index(min(self.cost_populations))\\r\\n \\r\\n if loopindex < int(self.population_size / 2):\\r\\n self.best_districts.append(self.district_population[index])\\r\\n self.best_costs.append(self.cost_populations[index])\\r\\n else:\\r\\n self.worst_districts.append(self.district_population[index])\\r\\n \\r\\n del self.cost_populations[index]\\r\\n del self.district_population[index]\",\n \"def _GetEpiOrder(self):\\n self.epi_series.sort()\\n for series in self.epi_series:\\n self.GetEpiAcqTimes(series)\\n self.AssignEpiNames()\",\n \"def get_Pre_Succ(I):\\n #Docs = I.docs\\n #Docs_id = Docs.keys()\\n Docs = I.getIndex().all_ids_\\n Docs_id = [ int(float(k)) for k in Docs] \\n N_pgs = len(Docs_id)\\n Index_P = { id:idx for idx,id in enumerate(Docs_id)}\\n Counter_Index_P = { idx:id for idx,id in enumerate(Docs_id)}\\n \\n print \\\"\\\\nBuilding Pi...\\\"\\n Succ = { Index_P[p]:(I.getLinksForDoc(p),len(I.getLinksForDoc(p))) for p in Docs_id }\\n P = {}\\n for e in Succ:\\n succ_e,l_e = Succ[e]\\n for s in succ_e: \\n if Index_P.get(s,\\\"Unknown_Doc_id\\\") not in P:\\n P[Index_P.get(s,\\\"Unknown_Doc_id\\\")] = set()\\n P[Index_P.get(s,\\\"Unknown_Doc_id\\\")].add(e) \\n \\n return P,Succ,Index_P,Counter_Index_P,N_pgs\",\n \"def PGL_order(A):\\n\\n n = 1\\n AA = PGL_repn(A)\\n B = copy(AA)\\n while B[0][0] != B[1][1] or B[0][1] != 0 or B[1][0] != 0:\\n n = n + 1\\n B = AA*B\\n\\n return n\",\n \"def custom_sort(arr):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6440761","0.6183674","0.58891386","0.5887252","0.5864489","0.5768664","0.5755941","0.5731223","0.5588322","0.55396104","0.5513205","0.54945284","0.5487258","0.54705155","0.54693717","0.5463505","0.5420143","0.5404942","0.5398548","0.538597","0.53687453","0.5363102","0.53523713","0.534749","0.5346655","0.5337432","0.53358537","0.5321288","0.53210545","0.5300303","0.5287456","0.52827513","0.526382","0.5252765","0.5241779","0.5241755","0.52390057","0.52247113","0.51958","0.519101","0.51831615","0.5179174","0.51759773","0.5158451","0.5155363","0.5138955","0.51262766","0.51226485","0.5115563","0.5114274","0.51061636","0.5102244","0.50932246","0.5074931","0.50673187","0.5067155","0.5053485","0.50417423","0.5038483","0.5025379","0.50211203","0.49975914","0.49903122","0.4985145","0.49590108","0.49577472","0.4955188","0.49521545","0.495209","0.49474686","0.49417374","0.4935589","0.493347","0.49301487","0.4926936","0.4924399","0.49209404","0.49191085","0.4914893","0.49137476","0.49074093","0.49051717","0.49013713","0.4901145","0.49008662","0.48952523","0.48945573","0.48933312","0.48921022","0.4883142","0.48820856","0.4881068","0.48798484","0.48761794","0.487527","0.4868085","0.48671657","0.4866224","0.48627254","0.48619696","0.48604247"],"string":"[\n \"0.6440761\",\n \"0.6183674\",\n \"0.58891386\",\n \"0.5887252\",\n \"0.5864489\",\n \"0.5768664\",\n \"0.5755941\",\n \"0.5731223\",\n \"0.5588322\",\n \"0.55396104\",\n \"0.5513205\",\n \"0.54945284\",\n \"0.5487258\",\n \"0.54705155\",\n \"0.54693717\",\n \"0.5463505\",\n \"0.5420143\",\n \"0.5404942\",\n \"0.5398548\",\n \"0.538597\",\n \"0.53687453\",\n \"0.5363102\",\n \"0.53523713\",\n \"0.534749\",\n \"0.5346655\",\n \"0.5337432\",\n \"0.53358537\",\n \"0.5321288\",\n \"0.53210545\",\n \"0.5300303\",\n \"0.5287456\",\n \"0.52827513\",\n \"0.526382\",\n \"0.5252765\",\n \"0.5241779\",\n \"0.5241755\",\n \"0.52390057\",\n \"0.52247113\",\n \"0.51958\",\n \"0.519101\",\n \"0.51831615\",\n \"0.5179174\",\n \"0.51759773\",\n \"0.5158451\",\n \"0.5155363\",\n \"0.5138955\",\n \"0.51262766\",\n \"0.51226485\",\n \"0.5115563\",\n \"0.5114274\",\n \"0.51061636\",\n \"0.5102244\",\n \"0.50932246\",\n \"0.5074931\",\n \"0.50673187\",\n \"0.5067155\",\n \"0.5053485\",\n \"0.50417423\",\n \"0.5038483\",\n \"0.5025379\",\n \"0.50211203\",\n \"0.49975914\",\n \"0.49903122\",\n \"0.4985145\",\n \"0.49590108\",\n \"0.49577472\",\n \"0.4955188\",\n \"0.49521545\",\n \"0.495209\",\n \"0.49474686\",\n \"0.49417374\",\n \"0.4935589\",\n \"0.493347\",\n \"0.49301487\",\n \"0.4926936\",\n \"0.4924399\",\n \"0.49209404\",\n \"0.49191085\",\n \"0.4914893\",\n \"0.49137476\",\n \"0.49074093\",\n \"0.49051717\",\n \"0.49013713\",\n \"0.4901145\",\n \"0.49008662\",\n \"0.48952523\",\n \"0.48945573\",\n \"0.48933312\",\n \"0.48921022\",\n \"0.4883142\",\n \"0.48820856\",\n \"0.4881068\",\n \"0.48798484\",\n \"0.48761794\",\n \"0.487527\",\n \"0.4868085\",\n \"0.48671657\",\n \"0.4866224\",\n \"0.48627254\",\n \"0.48619696\",\n \"0.48604247\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12897,"cells":{"query":{"kind":"string","value":"usalbe only when g_wc was used to find pr_wv"},"document":{"kind":"string","value":"def get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode):\r\n cnt_list =[]\r\n for b, g_wvi1 in enumerate(g_wvi):\r\n g_wc1 = g_wc[b]\r\n pr_wvi1 = pr_wvi[b]\r\n pr_wn1 = len(pr_wvi1)\r\n g_wn1 = g_wn[b]\r\n\r\n # Now sorting.\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx1 = argsort(array(g_wc1))\r\n elif mode == 'train':\r\n idx1 = list( range( g_wn1) )\r\n else:\r\n raise ValueError\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n flag = True\r\n for i_wn, idx11 in enumerate(idx1):\r\n g_wvi11 = g_wvi1[idx11]\r\n pr_wvi11 = pr_wvi1[i_wn]\r\n if g_wvi11 != pr_wvi11:\r\n flag = False\r\n # print(g_wv1, g_wv11)\r\n # print(pr_wv1, pr_wv11)\r\n # input('')\r\n break\r\n if flag:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n\r\n return cnt_list"},"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_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode):\r\n cnt_list =[]\r\n for b, g_wc1 in enumerate(g_wc):\r\n pr_wn1 = len(pr_sql_i[b][\"conds\"])\r\n g_wn1 = g_wn[b]\r\n\r\n # Now sorting.\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx1 = argsort(array(g_wc1))\r\n elif mode == 'train':\r\n idx1 = list( range( g_wn1) )\r\n else:\r\n raise ValueError\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n flag = True\r\n for i_wn, idx11 in enumerate(idx1):\r\n g_wvi_str11 = str(g_sql_i[b][\"conds\"][idx11][2]).lower()\r\n pr_wvi_str11 = str(pr_sql_i[b][\"conds\"][i_wn][2]).lower()\r\n # print(g_wvi_str11)\r\n # print(pr_wvi_str11)\r\n # print(g_wvi_str11==pr_wvi_str11)\r\n if g_wvi_str11 != pr_wvi_str11:\r\n flag = False\r\n # print(g_wv1, g_wv11)\r\n # print(pr_wv1, pr_wv11)\r\n # input('')\r\n break\r\n if flag:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n\r\n return cnt_list","def _compute_wo(self):\n self.uom_id = self.wo_id.uom_id.id\n self.final_product_id = self.wo_id.final_product_id.id\n if not self.supplier_id:\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\n else:\n service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\n if service_ids:\n product_supp_rcs = self.env['product.supplierinfo'].search([('partner_id', '=', self.supplier_id.id), ('product_id', 'in', service_ids)])\n if product_supp_rcs:\n product_ids = [x.product_id.id for x in product_supp_rcs if x.product_id]\n else:\n product_ids = []\n else:\n product_ids = [] \n \n self.service_ids = product_ids\n \n # Permet de savoir si l'OT suivant est de sous-traitance et qu'il y a qu'un seul OT suivant\n no_direct_fp = True\n if self.wo_id.next_wo_ids and len(self.wo_id.next_wo_ids) == 1 and self.wo_id.next_wo_ids[0].is_subcontracting and self.wo_id.next_wo_ids[0].consumed_service_ids:\n no_direct_fp = False\n \n self.no_direct_fp = no_direct_fp","def convert_pr_wvi_to_string(pr_wvi, nlu_t, nlu_wp_t, wp_to_wh_index, nlu):\r\n pr_wv_str_wp = [] # word-piece version\r\n pr_wv_str = []\r\n for b, pr_wvi1 in enumerate(pr_wvi):\r\n pr_wv_str_wp1 = []\r\n pr_wv_str1 = []\r\n wp_to_wh_index1 = wp_to_wh_index[b]\r\n nlu_wp_t1 = nlu_wp_t[b]\r\n nlu_t1 = nlu_t[b]\r\n\r\n for i_wn, pr_wvi11 in enumerate(pr_wvi1):\r\n st_idx, ed_idx = pr_wvi11\r\n\r\n # Ad-hoc modification of ed_idx to deal with wp-tokenization effect.\r\n # e.g.) to convert \"butler cc (\" ->\"butler cc (ks)\" (dev set 1st question).\r\n pr_wv_str_wp11 = nlu_wp_t1[st_idx:ed_idx+1]\r\n pr_wv_str_wp1.append(pr_wv_str_wp11)\r\n\r\n st_wh_idx = wp_to_wh_index1[st_idx]\r\n ed_wh_idx = wp_to_wh_index1[ed_idx]\r\n pr_wv_str11 = nlu_t1[st_wh_idx:ed_wh_idx+1]\r\n\r\n pr_wv_str1.append(pr_wv_str11)\r\n\r\n pr_wv_str_wp.append(pr_wv_str_wp1)\r\n pr_wv_str.append(pr_wv_str1)\r\n\r\n return pr_wv_str, pr_wv_str_wp","def unknown(self, w):\n # WORK HERE!!","def _compute_wo(self):\n self.uom_id = self.wo_id.uom_id.id\n self.final_product_id = self.wo_id.final_product_id.id\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]","def get_wm_ws_Gx_bot(self):\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \n z_u_r = self.grid_dict['z_u_r']\n z_u_w = self.grid_dict['z_u_w']\n [Ly,N] = self.b.shape\n #---> j-loop\n for j in range(Ly): \n self.kbl[j] = N # initialize search\n #-> end j-loop\n\n #--> k-loop\n for k in range(N-1,0,-1):\n k_w = k\n k_r = k-1\n # --> j loop \n for j in range(Ly):\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\n self.kbl[j] = k_w\n\n #--> end k\n # --> end j\n\n\n '''\n Compute nondimenisonal shape function coefficeints Gx() by\n matching values and vertical derivatives of interior mixing\n coefficients at hbbl (sigma=1)\n '''\n\n self.Gm1_bot = np.zeros([Ly])\n self.dGm1_dS_bot = np.zeros([Ly])\n self.Gt1_bot = np.zeros([Ly])\n self.dGt1_dS_bot = np.zeros([Ly]) \n self.Av_bl_bot = np.zeros([Ly])\n self.dAv_bl_bot = np.zeros([Ly]) \n self.cff_up_bot = np.zeros([Ly])\n self.cff_dn_bot = np.zeros([Ly])\n\n\n\n\n\n self.wm_bot = np.zeros([Ly])\n self.ws_bot = np.zeros([Ly]) \n\n # CALCULATE ustar for the bottom based on bototm velocities\n \n \n \n # CALCULATE r_D\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \n u = self.u\n v_upts = TTTW_func.v2u(self.v)\n \n ubar = np.mean(u,axis=1)\n vbar = np.mean(v_upts,axis=1)\n\n # --> j loop\n for j in range(Ly):\n # turbulent velocity sclaes with buoyancy effects neglected\n if self.CD_SWITCH:\n # DEPTH AVERAGED APPROACH\n uref = u[j,0]\n vref = v_upts[j,0]\n ustar2 = self.C_D * (uref**2 + vref**2)\n else:\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\n wm = self.vonKar * np.sqrt(ustar2)\n ws = wm\n\n self.wm_bot[j] = wm\n self.ws_bot[j] = ws\n \n k_w = self.kbl[j] \n z_bl = z_u_w[j,0] + self.hbbl[j]\n\n if z_bl < z_u_w[j,k_w-1]:\n k_w = k_w-1\n\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl_bot[j] = Av_bl\n self.dAv_bl_bot[j] = dAv_bl\n\n\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\n\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])","def grounding_words(self, w):\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])","def wisdom(search_me, source, pdfurl, userid):\n ### source needs to be name of data source (\"arxiv\", \"google scholar\", \"doaj\")\n search_me = search_me.strip()\n # check if pdfurl has been found before\n pdf = db_summaries.find_one({\"url\": pdfurl})\n if pdf:\n text = pdf.get('text')\n summary = pdf.get('summary')\n topics = pdf.get('topics')\n # update in db if data is 1 days or older\n last_updated = datetime.utcnow() - pdf.get(\"last_updated\")\n last_updated_diff = last_updated.days\n if last_updated_diff > 1:\n search_term = db_search_terms.find_one({\"value\": search_me.lower()})\n search_id = search_term.get(\"_id\")\n data = {\"search_id\": search_id,\n \"url\": pdfurl, \"source\": source, \"text\": text,\n \"summary\": summary, \"topics\": topics, \"last_updated\": datetime.utcnow()}\n db_summaries.update({\"url\": pdfurl}, {\"$set\": data})\n else:\n pass\n else:\n text = wisdomaiengine.pdfdocumentextracter(pdfurl)\n summary = wisdomaiengine.summarisepdfdocument(text)\n topics = wisdomaiengine.wordcloud(search_me, text)\n if topics is None:\n topics = ['No Topics Found']\n # write data to arxiv collection\n search_term = db_search_terms.find_one({\"value\": search_me.lower()})\n search_id = search_term.get(\"_id\")\n data = {\"search_id\": search_id,\n \"url\": pdfurl,\n \"source\": source,\n \"text\": text,\n \"summary\": summary,\n \"topics\": topics,\n \"last_updated\": datetime.utcnow()}\n x = db_summaries.insert(data, check_keys=False)\n # return json\n summaryjson = jsonify(wisdomtopics=topics, wisdomsummary=summary)\n return summaryjson","def get_wotd():\n\treturn wotd","def _get_wred(self):\n return self.__wred","def _get_wred(self):\n return self.__wred","def _get_wred(self):\n return self.__wred","def get_warc(self):\n raise NotImplementedError()","def svn_info_t_has_wc_info_get(svn_info_t_self): # real signature unknown; restored from __doc__\n pass","def wing(self):\n return","def is_wcw(status):\n test_text = ' '.join(status['text'].lower().split()) # Remove capital letters and excessive whitespace/linebreaks\n usernames = ['just_to_say_bot', 'thisisjustbot', 'Dcd200S', 'willslostplum', 'sosweetbot', 'JustToSayBot', 'thatisjustplums', \\\n\t\t 'EatenBot', 'the_niche_bot', 'KristenCostel10', 'litabottal', 'pythonnina', 'alatest5', 'LisaRob96585017','Stilson28400122', \\\n\t\t 'JohnDun40217560','Cordelia28', 'Rick63556459', 'botsnthings', 'timbot301', 'Rachel53001595', 'NicholasMillma6', 'ThisIsJustTo1'\\\n\t\t'MayISay4', 'breakfast_plum', 'BotBot53368932'] # Block screen_names of known parody accounts\n if status['user']['screen_name'] not in usernames and all(u not in status['text'] for u in usernames) and 'Cheap Bots, Done Quick!' not in status['source']:\n if 'which you were probably' in test_text: # Capture parodies of the form\n return True\n elif 'plums' in test_text and 'icebox' in test_text: # Capture parodies of the content\n return True\n elif 'plum' in test_text and 'icebox' in test_text: # Capture singular 'plum'\n return True\n elif 'plums' in test_text and 'ice box' in test_text: #Capture 'ice box' with a space\n return True\n elif 'plum' in test_text and 'ice box' in test_text: \n return True\n elif 'William Carlos Williams'.lower() in test_text and 'plums' in test_text: #Capture mentions of WCW\n return True\n elif 'William Carlos Williams'.lower() in test_text and 'plum' in test_text:\n return True\n elif 'this is just to say' in test_text and 'that were in' in test_text: # Get only relevant instances of \"this is just to say\"\n return True\n elif 'this is just to say' in test_text and 'forgive me' in test_text:\n return True\n elif 'this is just to say' in test_text and 'and so' in test_text:\n return True\n elif 'so sweet and so cold' in test_text and 'the arms of the ocean' not in test_text: # Get 'so sweet and so cold' tweets that aren't quoting Florence and the Machine\n return True\n else:\n return False\n else:\n return False","def get_WS(w2v):\n # get set of MAX_NGRAM-grams in text\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 ngrams_in_data = set()\n for words in raw:\n for ngram in tweet_to_ngrams(words):\n ngrams_in_data.add(ngram)\n\n # load sentiment features from model\n clf_pipe = pickle.load(open(CLF_FNAME, 'rb')) # model\n\n vect = clf_pipe.best_estimator_.named_steps['vect']\n clf = clf_pipe.best_estimator_.named_steps['clf']\n\n features_to_sent_idx = vect.vocabulary_ # map from model features to sentiment index\n # currently, sentiment = 2 * (count_pos / (count_pos + count_neg)) - 1\n sentiments = clf.feature_count_[1,:] / np.sum(clf.feature_count_, axis=0) # in [0,1]\n sentiments = 2 * sentiments - 1 # rescale to [-1,1]\n\n features_to_sent = {feat: sentiments[idx] for (feat,idx) in features_to_sent_idx.items()}\n\n # build WS and ngram_idx_map for each MAX_NGRAM-gram in the text\n k = len(next(iter(w2v.values()))) # dimension of embedding\n WS = np.zeros(shape=(len(ngrams_in_data) + 1, k + MAX_NGRAM), dtype='float32')\n ngram_idx_map = {}\n\n index = 1 # first row is left 0, for padding in the cnn. This is also neutral sentiment.\n # For Vader Sentiment analysis\n# vader_analyzer = SentimentIntensityAnalyzer()\n\n\n for ngram in ngrams_in_data:\n ngram_idx_map[ngram] = index\n\n # set word embedding, note that unknown words already randomized in load_embedding \n words = ngram.split(' ')\n WS[index,:k] = w2v[words[-1]] # embedding of last word\n\n # set sentiment embedding\n for n in range(MAX_NGRAM): # for 1, 2, ... length ngrams\n sub_ngram = ' '.join(words[-1 - n:]) \n\n # Naive Bayes Sentiment feature --------------------------------\n sent = features_to_sent.get(sub_ngram, 0.0) # default to neutral 0\n # --------------------------------------------------------------\n\n# # TextBlob sentiment feature -----------------------------------\n# sent = TextBlob(sub_ngram).sentiment.polarity\n# # --------------------------------------------------------------\n\n# # Vader sentiment feature -------------------------------------\n# sent = vader_analyzer.polarity_scores(sub_ngram)['compound']\n# # -------------------------------------------------------------\n WS[index,k+n] = sent\n\n index += 1\n\n return WS, ngram_idx_map","def combined_wcs(self) -> BaseHighLevelWCS:","def get_cnt_sw_list(g_sc, g_sa, g_wn, g_wc, g_wo, g_wvi,\r\n pr_sc, pr_sa, pr_wn, pr_wc, pr_wo, pr_wvi,\r\n g_sql_i, pr_sql_i,\r\n mode):\r\n cnt_sc = get_cnt_sc_list(g_sc, pr_sc)\r\n cnt_sa = get_cnt_sc_list(g_sa, pr_sa)\r\n cnt_wn = get_cnt_sc_list(g_wn, pr_wn)\r\n cnt_wc = get_cnt_wc_list(g_wc, pr_wc)\r\n cnt_wo = get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode)\r\n if pr_wvi:\r\n cnt_wvi = get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode)\r\n else:\r\n cnt_wvi = [0]*len(cnt_sc)\r\n cnt_wv = get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode) # compare using wv-str which presented in original data.\r\n\r\n\r\n return cnt_sc, cnt_sa, cnt_wn, cnt_wc, cnt_wo, cnt_wvi, cnt_wv","def handlehtmlsearch_wok(querystring, keywordstring, searchlimit, cache, smartconstrain):\n mpsearch, keywords, constraints = handlehtmlsearch_mp(querystring, keywordstring, cache, smartconstrain)\n\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'rt') as record:\n try:\n wlist = json.load(record)\n except ValueError:\n wlist = {}\n\n searchtotal = 0\n for search in mpsearch:\n searchtotal += len(search)\n\n wokresults = []\n i = 0\n\n for search in mpsearch:\n for n in search:\n iterinput = []\n for m in n['unit_cell_formula'].keys():\n iterinput.append(m + str(int(n['unit_cell_formula'][m])))\n\n iterlist = list(itertools.permutations(iterinput))\n\n searchparam = 'topic:' + n['pretty_formula'] + ' or topic:' + n['full_formula']\n\n for term in iterlist:\n searchparam += ' or topic:' + ''.join(term)\n\n i += 1\n if n['material_id'] in wlist.keys() and cache:\n print('loading wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\n wokresults.append(wlist[n['material_id']])\n else:\n print('searching wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\n try:\n searchdata = searchWoKTools.getsearchdata(searchparam, searchlimit)\n except:\n with open('wokRecord.json', 'wt') as record:\n json.dump(wlist, record)\n raise\n\n searchdata[0].update(n)\n wlist[n['material_id']] = searchdata\n wokresults.append(searchdata)\n\n mpsearch, wokresults = searchWoKTools.removeconstrainedwok(mpsearch, wokresults, constraints)\n\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'wt') as record:\n json.dump(wlist, record)\n\n keyresults = []\n for search in wokresults:\n keyresults.append(searchWoKTools.getkeylist(search, keywords))\n\n return keywords, mpsearch, wokresults, keyresults","def pwgrwlfilter(self):\n return None","def treat_page(self):\n # let's define some basic variables\n urtext = self.current_page.text\n urlang = self.current_page.site.code\n urtitle = self.current_page.title()\n urcat = []\n eng_site = pywikibot.Site('en')\n eng_title = ''\n \n interDict = {}\n try:\n site = pywikibot.Site('ur', 'wikipedia')\n urpage = pywikibot.Page(site, urtitle)\n langlst = urpage.iterlanglinks()\n\n \n for i in langlst:\n lang = str(i.site).split(':')[1]\n interDict[lang] = i.title\n \n eng_title = interDict['en']\n except:\n pywikibot.output(u'\\03{lightred}Unable to fetch interwiki links!\\03{default}')\n return False\n \n site = pywikibot.Site('en', 'wikipedia')\n enpage = pywikibot.Page(site, eng_title)\n\n wikitext = enpage.get() \n wikicode = mwp.parse(wikitext)\n\n # Extracting sfn templates and converting them in REF tags\n sfnlist = []\n for template in wikicode.filter_templates():\n if template.name in ('sfn', 'sfn'):\n sfnlist.append(template)\n templ_rep = '<ref>' + str(template) + '</ref>'\n wikicode.replace(template , templ_rep)\n\n alltags = wikicode.filter_tags() \n reftags = {}\n \n def search(myDict, search1):\n for key, value in myDict.items():\n if search1 in value: \n return key \n \n i=1\n for tag in alltags:\n if tag.tag=='ref':\n if tag.attributes == []: # check if attributes list is empty\n refval='NoRefName' # Reference has no name so assigning \"NoRefName\"\n else:\n name = tag.attributes[0]\n refval = name.value\n \n if tag.contents is None:\n #conval = search(reftags,refval)\n #reftags[i] = (refval,reftags[conval][1])\n pass\n else: \n reftags[i] = (refval,tag.contents)\n i += 1\n\n dlinks = {}\n for k,v in reftags.items():\n dkey = 'و' + str(k) + 'و'\n dlinks[dkey] = '<ref>' + str(v[1]) + '</ref>'\n\n urtext = urpage.text\n for r in tuple(dlinks.items()):\n urtext = urtext.replace(*r)\n\n # newln = '\\n'\n # Using noreferences to add Reference template if not present\n self.norefbot = noreferences.NoReferencesBot(None)\n if self.norefbot.lacksReferences(urtext):\n urtext = self.norefbot.addReferences(urtext)\n else:\n urpage.text = urtext + '\\n'\n\n print(urpage.text)\n \n # save the page \n urpage.save(summary=self.summary, minor=False)\n #self.put_current(urpage.text, summary=self.summary)","def CC_wdw(self):\n # Setup param\n loc = 'TSdata'\n if 'single' == self.newParam['survey_type']:\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc).shape[0]\n elif 'multiple' == self.newParam['survey_type']:\n TS_group = dt.utilities.DB_group_names(self.Database, group_name = loc)[0]\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc+'/'+TS_group).shape[0]\n\n param = self.newParam\n\n # Assign TS processing length to end_wdws if given\n if param['end_wdws']:\n TS_sig_len = param['end_wdws']\n else:\n TS_sig_len = TS_len\n\n ERROR_MESSAGE = 'The length of a TS signal to be processed is', TS_sig_len, \\\n 'which is < end of the last window'\n\n # Calculate wdwPos for overlapping windows of ww_ol if wdwPos is False\n if param['wdwPos'][0] is False:\n # Error checks\n if TS_sig_len < self.newParam['ww'][0]:\n raise Warning(ERROR_MESSAGE)\n\n wdwStep = np.floor(param['ww'][0] *\n (100 - param['ww_ol']) / 100)\n\n if self.verbose: print('* Length fo TSdata', TS_len)\n\n max_wdwPos = TS_sig_len - param['ww'][0] + 1\n wdwStarts = np.arange(0 + param['sta_wdws'], max_wdwPos, wdwStep).astype(int)\n\n if self.verbose: print('* The step in window potions is %s sample points' % wdwStep)\n if self.verbose: print('* The max window postions is %s sample points'% max_wdwPos)\n\n param['wdwPos'] = [ [wdw_start, wdw_start + param['ww'][0]] for\n wdw_start in wdwStarts ]\n\n # Only update wdwPos structure if not already done so\n elif np.array(param['wdwPos'][0]).shape == ():\n param['wdwPos'] = [ [wdw_start, wdw_start + ww] for wdw_start,ww in\n zip(param['wdwPos'], param['ww'])]\n\n self.newParam['wdwPos'] = param['wdwPos']","def fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw):\n\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\n\tTocwf=Vk*Ck*Dk/GDen\n\treturn Tocwf","def buildWPriorTerm(self):\r\n\r\n # self.w_prior.shape == (minibatch size,)\r\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\r\n\r\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)","def wkt(self): # -> str:\n ...","def _new_wos_dict():\n wos_dict = {\n 'DI': None,\n 'TI': None,\n 'PY': None,\n 'SO': None,\n 'UT': None,\n 'DE': None,\n }\n\n return wos_dict","def wing_geom_eval(self, cpacs):\n\n log.info(\"---------- Analysing wing geometry ----------\")\n\n # Opening tixi and tigl\n tixi = cpacs.tixi\n tigl = cpacs.tigl\n\n # Counting wing number without symmetry --------------------------------------\n w_nb = tixi.getNamedChildrenCount(WINGS_XPATH, \"wing\")\n\n # INITIALIZATION 1 -----------------------------------------------------------\n self.w_nb = w_nb\n self.wing_nb = w_nb\n wing_plt_area_xz = []\n wing_plt_area_yz = []\n wingUID = []\n\n # Counting sections and segments----------------------------------------------\n b = 0\n for i in range(1, w_nb + 1):\n double = 1\n self.wing_sym.append(tigl.wingGetSymmetry(i))\n if self.wing_sym[i - 1] != 0:\n double = 2 # To consider the real amount of wing\n # when they are defined using symmetry\n self.wing_nb += 1\n self.wing_sec_nb.append(tigl.wingGetSectionCount(i))\n self.wing_seg_nb.append(tigl.wingGetSegmentCount(i))\n self.wing_vol.append(tigl.wingGetVolume(i) * double)\n\n self.wing_plt_area.append(tigl.wingGetReferenceArea(i, 1) * double) # x-y plane\n wing_plt_area_xz.append(tigl.wingGetReferenceArea(i, 2) * double) # x-z plane\n wing_plt_area_yz.append(tigl.wingGetReferenceArea(i, 3) * double) # y-z plane\n\n self.wing_tot_vol = self.wing_tot_vol + self.wing_vol[i - 1]\n wingUID.append(tigl.wingGetUID(i))\n self.wing_span.append(tigl.wingGetSpan(wingUID[i - 1]))\n a = np.amax(self.wing_span)\n # Evaluating the index that corresponds to the main wing\n if a > b:\n self.main_wing_index = i\n b = a\n\n # Checking segment and section connection and reordering them\n (\n self.wing_sec_nb,\n _,\n seg_sec,\n _,\n ) = self.wing_check_segment_connection(wing_plt_area_xz, wing_plt_area_yz, tigl)\n\n # INITIALIZATION 2 -----------------------------------------------------------\n\n max_wing_sec_nb = np.amax(self.wing_sec_nb)\n max_wing_seg_nb = np.amax(self.wing_seg_nb)\n wing_center_section_point = np.zeros((max_wing_sec_nb, w_nb, 3))\n self.wing_center_seg_point = np.zeros((max_wing_seg_nb, self.wing_nb, 3))\n self.wing_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\n self.wing_fuel_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\n self.wing_fuel_vol = 0\n self.wing_mac = np.zeros((4, w_nb))\n self.wing_sec_thickness = np.zeros((max_wing_sec_nb + 1, w_nb))\n\n # WING ANALYSIS --------------------------------------------------------------\n\n # Main wing plantform area\n self.wing_plt_area_main = self.wing_plt_area[self.main_wing_index - 1]\n\n # Wing: MAC,chords,thickness,span,plantform area ------------------------------\n\n for i in range(1, w_nb + 1):\n mac = tigl.wingGetMAC(wingUID[i - 1])\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, 1, 0.0, 0.0)\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, 1, 0.0, 1.0)\n self.wing_max_chord.append(\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\n )\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 0.0)\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 1.0)\n self.wing_min_chord.append(\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\n )\n for k in range(1, 5):\n self.wing_mac[k - 1][i - 1] = mac[k - 1]\n for jj in range(1, self.wing_seg_nb[i - 1] + 1):\n j = int(seg_sec[jj - 1, i - 1, 2])\n cle = tigl.wingGetChordPoint(i, j, 0.0, 0.0)\n self.wing_seg_vol[j - 1][i - 1] = tigl.wingGetSegmentVolume(i, j)\n lp = tigl.wingGetLowerPoint(i, j, 0.0, 0.0)\n up = tigl.wingGetUpperPoint(i, j, 0.0, 0.0)\n if np.all(cle == lp):\n L = 0.25\n else:\n L = 0.75\n if np.all(cle == up):\n U = 0.25\n else:\n U = 0.75\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, j, 0.0, L)\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, j, 0.0, U)\n wing_center_section_point[j - 1][i - 1][0] = (wplx + wpux) / 2\n wing_center_section_point[j - 1][i - 1][1] = (wply + wpuy) / 2\n wing_center_section_point[j - 1][i - 1][2] = (wplz + wpuz) / 2\n self.wing_sec_thickness[j - 1][i - 1] = np.sqrt(\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\n )\n j = int(seg_sec[self.wing_seg_nb[i - 1] - 1, i - 1, 2])\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, self.wing_seg_nb[i - 1], 1.0, L)\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, self.wing_seg_nb[i - 1], 1.0, U)\n self.wing_sec_thickness[j][i - 1] = np.sqrt(\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\n )\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][0] = (wplx + wpux) / 2\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][1] = (wply + wpuy) / 2\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][2] = (wplz + wpuz) / 2\n self.wing_sec_mean_thick.append(\n np.mean(self.wing_sec_thickness[0 : self.wing_seg_nb[i - 1] + 1, i - 1])\n )\n # Evaluating wing fuel tank volume in the main wings\n if abs(round(self.wing_plt_area[i - 1], 3) - self.wing_plt_area_main) < 0.001:\n tp_ratio = self.wing_min_chord[i - 1] / self.wing_max_chord[i - 1]\n ratio = round(tp_ratio * self.wing_plt_area[i - 1] / 100, 1)\n if ratio >= 1.0:\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.8, 2)\n elif ratio >= 0.5:\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.72, 2)\n else:\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.5, 2)\n for j in seg_sec[:, i - 1, 2]:\n if j == 0.0:\n break\n self.wing_fuel_seg_vol[int(j) - 1][i - 1] = round(\n (self.wing_seg_vol[int(j) - 1][i - 1] / (sum(self.wing_vol)))\n * self.wing_fuel_vol,\n 2,\n )\n if (\n self.wing_plt_area[i - 1] > wing_plt_area_xz[i - 1]\n and self.wing_plt_area[i - 1] > wing_plt_area_yz[i - 1]\n ):\n self.is_horiz.append(True)\n if self.wing_sym[i - 1] != 0:\n self.is_horiz.append(True)\n else:\n self.is_horiz.append(False)\n if self.wing_sym[i - 1] != 0:\n self.is_horiz.append(False)\n\n # Wing segment length evaluating function\n self.get_wing_segment_length(wing_center_section_point)\n\n # Evaluating the point at the center of each segment, the center\n # is placed at 1/4 of the chord, symmetry is considered.\n\n a = 0\n c = False\n for i in range(1, int(self.wing_nb) + 1):\n if c:\n c = False\n continue\n for jj in range(1, self.wing_seg_nb[i - a - 1] + 1):\n j = int(seg_sec[jj - 1, i - a - 1, 2])\n self.wing_center_seg_point[j - 1][i - 1][0] = (\n wing_center_section_point[j - 1][i - a - 1][0]\n + wing_center_section_point[j][i - a - 1][0]\n ) / 2\n self.wing_center_seg_point[j - 1][i - 1][1] = (\n wing_center_section_point[j - 1][i - a - 1][1]\n + wing_center_section_point[j][i - a - 1][1]\n ) / 2\n self.wing_center_seg_point[j - 1][i - 1][2] = (\n wing_center_section_point[j - 1][i - a - 1][2]\n + wing_center_section_point[j][i - a - 1][2]\n ) / 2\n if self.wing_sym[i - 1 - a] != 0:\n if self.wing_sym[i - 1 - a] == 1:\n symy = 1\n symx = 1\n symz = -1\n if self.wing_sym[i - 1 - a] == 2:\n symy = -1\n symx = 1\n symz = 1\n if self.wing_sym[i - 1 - a] == 3:\n symy = 1\n symx = -1\n symz = 1\n self.wing_center_seg_point[:, i, 0] = (\n self.wing_center_seg_point[:, i - 1, 0] * symx\n )\n self.wing_center_seg_point[:, i, 1] = (\n self.wing_center_seg_point[:, i - 1, 1] * symy\n )\n self.wing_center_seg_point[:, i, 2] = (\n self.wing_center_seg_point[:, i - 1, 2] * symz\n )\n c = True\n a += 1\n\n self.w_seg_sec = seg_sec\n\n self.wing_area = round(self.wing_plt_area_main, 3)\n\n log.info(\"---------------------------------------------\")\n log.info(\"--------------- Wing Results ----------------\")\n log.info(f\"Number of Wings [-]: {self.wing_nb}\")\n log.info(f\"Wing symmetry plane [-]: {self.wing_sym}\")\n log.info(f\"Number of wing sections (not counting symmetry) [-]: {self.wing_sec_nb}\")\n log.info(f\"Number of wing segments (not counting symmetry) [-]: {self.wing_seg_nb}\")\n log.info(f\"Wing Span [m]: {self.wing_span}\")\n log.info(f\"Wing MAC length [m]: {self.wing_mac[0,]}\")\n log.info(f\"Wing max chord length [m]: {self.wing_max_chord}\")\n log.info(f\"Wing min chord length [m]: {self.wing_min_chord}\")\n log.info(f\"Main wing plantform area [m^2]: {self.wing_plt_area_main}\")\n log.info(f\"Wings plantform area [m^2]: {self.wing_plt_area}\")\n log.info(f\"Volume of each wing [m^3]: {self.wing_vol}\")\n log.info(f\"Total wing volume [m^3]: {self.wing_tot_vol}\")\n log.info(f\"Wing volume for fuel storage [m^3]: {self.wing_fuel_vol}\")\n log.info(\"---------------------------------------------\")","def get_wo_mthly_smry(self, workorder_browse):\n wo_summary_data = []\n wo_check_dict = {}\n no = 0\n if workorder_browse:\n for work_rec in workorder_browse:\n if work_rec.state and work_rec.state == \"done\":\n no += 1\n identification = \"\"\n repair_line_data = \"\"\n if work_rec.vehicle_id:\n identification += work_rec.vehicle_id.name\n if work_rec.vehicle_id.f_brand_id:\n identification += \" \" + work_rec.vehicle_id.f_brand_id.name\n if work_rec.vehicle_id.model_id:\n identification += \" \" + work_rec.vehicle_id.model_id.name\n for repaire_line in work_rec.repair_line_ids:\n if repaire_line.complete is True:\n if (\n repaire_line.repair_type_id\n and repaire_line.repair_type_id.name\n ):\n repair_line_data += (\n repaire_line.repair_type_id.name + \", \"\n )\n if work_rec.parts_ids:\n for parts_line in work_rec.parts_ids:\n if work_rec.id in wo_check_dict.keys():\n parts_data = {\n \"no\": -1,\n \"location\": \"\",\n \"type\": \"\",\n \"wo\": \"\",\n \"identification\": \"\",\n \"vin\": \"\",\n \"plate_no\": \"\",\n \"work_performed\": \"\",\n \"part\": parts_line.product_id\n and parts_line.product_id.default_code\n or \"\",\n \"qty\": parts_line.qty or 0.0,\n \"uom\": parts_line.product_uom\n and parts_line.product_uom.name\n or \"\",\n }\n wo_summary_data.append(parts_data)\n else:\n wo_check_dict[work_rec.id] = work_rec.id\n parts_data = {\n \"no\": no,\n \"location\": work_rec.team_id\n and work_rec.team_id.name\n or \"\",\n \"type\": work_rec.main_type or \"\",\n \"wo\": work_rec.name or \"\",\n \"identification\": identification or \"\",\n \"vin\": work_rec.vehicle_id\n and work_rec.vehicle_id.vin_sn\n or \"\",\n \"plate_no\": work_rec.vehicle_id\n and work_rec.vehicle_id.license_plate\n or \"\",\n \"work_performed\": repair_line_data\n and repair_line_data[:-2]\n or \"\",\n \"part\": parts_line.product_id\n and parts_line.product_id.default_code\n or \"\",\n \"qty\": parts_line.qty or 0.0,\n \"uom\": parts_line.product_uom\n and parts_line.product_uom.name\n or \"\",\n }\n wo_summary_data.append(parts_data)\n else:\n parts_data = {\n \"no\": no,\n \"location\": work_rec.team_id\n and work_rec.team_id.name\n or \"\",\n \"type\": work_rec.main_type or \"\",\n \"wo\": work_rec.name or \"\",\n \"identification\": identification or \"\",\n \"vin\": work_rec.vehicle_id\n and work_rec.vehicle_id.vin_sn\n or \"\",\n \"plate_no\": work_rec.vehicle_id\n and work_rec.vehicle_id.license_plate\n or \"\",\n \"work_performed\": repair_line_data\n and repair_line_data[:-2]\n or \"\",\n \"vehicle_make\": \"\",\n \"qty\": \"\",\n \"uom\": \"\",\n }\n wo_summary_data.append(parts_data)\n if not wo_summary_data:\n msg = _(\n \"Warning! \\n\\\n No data Available for selected work order.\"\n )\n raise UserError(msg)\n return wo_summary_data","def analyzeWeights(self, occludedPortions):\r\n\t\treturn None","def update(self):\n self.wc.update()","def original_wcs(self):\n return self._owcs","def lookup(doc, wv):\n checked = []\n for word in doc:\n try:\n word in wv\n except KeyError:\n log.warning(\"Word not in model: %s\", word)\n continue\n checked.append(wv[word])\n vec = np.mean(checked, axis=0)\n return vec","def give_wv_units(wave):\n if not hasattr(wave, 'unit'):\n uwave = u.Quantity(wave, unit=u.AA)\n elif wave.unit is None:\n uwave = u.Quantity(wave, unit=u.AA)\n else:\n uwave = u.Quantity(wave)\n\n return uwave","def wrez2xml(self,newdoc,newroot):\n\t\twrez = newdoc.createElement('wrez')\n\t\twrez.setAttribute('hasChanged', str(self.hasChanged))\n\t\tnewroot.appendChild(wrez)\n\n\t\tpath = newdoc.createElement('path')\n\t\tpath.setAttribute('value', self.path)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('init_str')\n\t\tpath.setAttribute('value', self.init_str)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('hash_sha512')\n\t\tpath.setAttribute('value', self.hash_sha512)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('src_rip')\n\t\tpath.setAttribute('value', self.src_rip)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('quality')\n\t\tpath.setAttribute('value', self.quality)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('codec')\n\t\tpath.setAttribute('value', self.codec)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('language')\n\t\tpath.setAttribute('value', self.language)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('audio')\n\t\tpath.setAttribute('value', self.audio)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('encoder')\n\t\tpath.setAttribute('value', self.encoder)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('version')\n\t\tpath.setAttribute('value', self.version)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('extension')\n\t\tpath.setAttribute('value', self.extension)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('release_year')\n\t\tpath.setAttribute('value', self.release_year)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('title')\n\t\tpath.setAttribute('value', self.title)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('size')\n\t\tpath.setAttribute('value', str(self.size))\n\t\twrez.appendChild(path)\n\t\treturn wrez","def get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode):\r\n cnt_list=[]\r\n for b, g_wo1 in enumerate(g_wo):\r\n g_wc1 = g_wc[b]\r\n pr_wc1 = pr_wc[b]\r\n pr_wo1 = pr_wo[b]\r\n pr_wn1 = len(pr_wo1)\r\n g_wn1 = g_wn[b]\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx = argsort(array(g_wc1))\r\n\r\n g_wo1_s = array(g_wo1)[idx]\r\n g_wo1_s = list(g_wo1_s)\r\n elif mode == 'train':\r\n # due to tearch forcing, no need to sort.\r\n g_wo1_s = g_wo1\r\n else:\r\n raise ValueError\r\n\r\n if type(pr_wo1) != list:\r\n raise TypeError\r\n if g_wo1_s == pr_wo1:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n return cnt_list","def onReload(self, event):\n\n\t\tself.wv.Reload()","def test_mlpi_cwro(self):\r\n\t\twith open(\"test_mlpi_cwro.txt\", \"w\") as test_mlpi_cwro_output:\r\n\t\t\tsys.stdout = test_mlpi_cwro_output\r\n\t\t\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=100, censor_words_one_pass=True)\r\n\t\twith open(\"test_mlpi_cwro.txt\", \"r\") as test_mlpi_cwro_output:\r\n\t\t\twhile True:\r\n\t\t\t\tline_output = test_mlpi_cwro_output.readline()\r\n\t\t\t\tline_correct = cc_test_prose.readline()\r\n\t\t\t\tself.assertEqual(line_output, line_correct)\r\n\t\t\t\tif line_correct == '':\r\n\t\t\t\t\tbreak\r\n\t\tcc_test_prose.seek(0)\r\n\t\tsys.stdout = sys.__stdout__\r\n\t\tos.remove(\"test_mlpi_cwro.txt\")","def primalrepair(self,wlc,wuc,wlx,wux): # 3\n if wlc is None:\n wlc_ = None\n else:\n try:\n wlc_ = memoryview(wlc)\n except TypeError:\n try:\n _tmparr_wlc = array.array(\"d\",wlc)\n except TypeError:\n raise TypeError(\"Argument wlc has wrong type\")\n else:\n wlc_ = memoryview(_tmparr_wlc)\n \n else:\n if wlc_.format != \"d\":\n wlc_ = memoryview(array.array(\"d\",wlc))\n \n if wlc_ is not None and len(wlc_) != self.getnumcon():\n raise ValueError(\"Array argument wlc has wrong length\")\n if wuc is None:\n wuc_ = None\n else:\n try:\n wuc_ = memoryview(wuc)\n except TypeError:\n try:\n _tmparr_wuc = array.array(\"d\",wuc)\n except TypeError:\n raise TypeError(\"Argument wuc has wrong type\")\n else:\n wuc_ = memoryview(_tmparr_wuc)\n \n else:\n if wuc_.format != \"d\":\n wuc_ = memoryview(array.array(\"d\",wuc))\n \n if wuc_ is not None and len(wuc_) != self.getnumcon():\n raise ValueError(\"Array argument wuc has wrong length\")\n if wlx is None:\n wlx_ = None\n else:\n try:\n wlx_ = memoryview(wlx)\n except TypeError:\n try:\n _tmparr_wlx = array.array(\"d\",wlx)\n except TypeError:\n raise TypeError(\"Argument wlx has wrong type\")\n else:\n wlx_ = memoryview(_tmparr_wlx)\n \n else:\n if wlx_.format != \"d\":\n wlx_ = memoryview(array.array(\"d\",wlx))\n \n if wlx_ is not None and len(wlx_) != self.getnumvar():\n raise ValueError(\"Array argument wlx has wrong length\")\n if wux is None:\n wux_ = None\n else:\n try:\n wux_ = memoryview(wux)\n except TypeError:\n try:\n _tmparr_wux = array.array(\"d\",wux)\n except TypeError:\n raise TypeError(\"Argument wux has wrong type\")\n else:\n wux_ = memoryview(_tmparr_wux)\n \n else:\n if wux_.format != \"d\":\n wux_ = memoryview(array.array(\"d\",wux))\n \n if wux_ is not None and len(wux_) != self.getnumvar():\n raise ValueError(\"Array argument wux has wrong length\")\n res = self.__obj.primalrepair(wlc_,wuc_,wlx_,wux_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def primalrepair(self,wlc_,wuc_,wlx_,wux_):\n _wlc_minlength = self.getnumcon()\n if self.getnumcon() > 0 and wlc_ is not None and len(wlc_) != self.getnumcon():\n raise ValueError(\"Array argument wlc is not long enough: Is %d, expected %d\" % (len(wlc_),self.getnumcon()))\n if isinstance(wlc_, numpy.ndarray) and wlc_.dtype is numpy.dtype(numpy.float64) and wlc_.flags.contiguous:\n _wlc_copyarray = False\n _wlc_tmp = ctypes.cast(wlc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wlc_ is not None:\n _wlc_copyarray = True\n _wlc_np_tmp = numpy.zeros(len(wlc_),numpy.dtype(numpy.float64))\n _wlc_np_tmp[:] = wlc_\n assert _wlc_np_tmp.flags.contiguous\n _wlc_tmp = ctypes.cast(_wlc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wlc_copyarray = False\n _wlc_tmp = None\n \n _wuc_minlength = self.getnumcon()\n if self.getnumcon() > 0 and wuc_ is not None and len(wuc_) != self.getnumcon():\n raise ValueError(\"Array argument wuc is not long enough: Is %d, expected %d\" % (len(wuc_),self.getnumcon()))\n if isinstance(wuc_, numpy.ndarray) and wuc_.dtype is numpy.dtype(numpy.float64) and wuc_.flags.contiguous:\n _wuc_copyarray = False\n _wuc_tmp = ctypes.cast(wuc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wuc_ is not None:\n _wuc_copyarray = True\n _wuc_np_tmp = numpy.zeros(len(wuc_),numpy.dtype(numpy.float64))\n _wuc_np_tmp[:] = wuc_\n assert _wuc_np_tmp.flags.contiguous\n _wuc_tmp = ctypes.cast(_wuc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wuc_copyarray = False\n _wuc_tmp = None\n \n _wlx_minlength = self.getnumvar()\n if self.getnumvar() > 0 and wlx_ is not None and len(wlx_) != self.getnumvar():\n raise ValueError(\"Array argument wlx is not long enough: Is %d, expected %d\" % (len(wlx_),self.getnumvar()))\n if isinstance(wlx_, numpy.ndarray) and wlx_.dtype is numpy.dtype(numpy.float64) and wlx_.flags.contiguous:\n _wlx_copyarray = False\n _wlx_tmp = ctypes.cast(wlx_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wlx_ is not None:\n _wlx_copyarray = True\n _wlx_np_tmp = numpy.zeros(len(wlx_),numpy.dtype(numpy.float64))\n _wlx_np_tmp[:] = wlx_\n assert _wlx_np_tmp.flags.contiguous\n _wlx_tmp = ctypes.cast(_wlx_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wlx_copyarray = False\n _wlx_tmp = None\n \n _wux_minlength = self.getnumvar()\n if self.getnumvar() > 0 and wux_ is not None and len(wux_) != self.getnumvar():\n raise ValueError(\"Array argument wux is not long enough: Is %d, expected %d\" % (len(wux_),self.getnumvar()))\n if isinstance(wux_, numpy.ndarray) and wux_.dtype is numpy.dtype(numpy.float64) and wux_.flags.contiguous:\n _wux_copyarray = False\n _wux_tmp = ctypes.cast(wux_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wux_ is not None:\n _wux_copyarray = True\n _wux_np_tmp = numpy.zeros(len(wux_),numpy.dtype(numpy.float64))\n _wux_np_tmp[:] = wux_\n assert _wux_np_tmp.flags.contiguous\n _wux_tmp = ctypes.cast(_wux_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wux_copyarray = False\n _wux_tmp = None\n \n res = __library__.MSK_XX_primalrepair(self.__nativep,_wlc_tmp,_wuc_tmp,_wlx_tmp,_wux_tmp)\n if res != 0:\n _,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def vp():\r\n section = document.add_section()\r\n new_width, new_height = section.page_height, section.page_width\r\n section.orientation = WD_ORIENT.LANDSCAPE\r\n section.page_width = 10058400\r\n section.page_height = 7772400\r\n document.add_heading('Virtual Proxy details', 1)\r\n virtualproxy_metrics= ['description', 'prefix', 'authenticationModuleRedirectUri', 'sessionModuleBaseUri', 'loadBalancingModuleBaseUri', 'authenticationMethod', 'headerAuthenticationMode',\r\n 'headerAuthenticationHeaderName', 'headerAuthenticationStaticUserDirectory', 'headerAuthenticationDynamicUserDirectory', 'anonymousAccessMode', 'windowsAuthenticationEnabledDevicePattern',\r\n 'sessionCookieHeaderName', 'sessionCookieDomain', 'additionalResponseHeaders', 'sessionInactivityTimeout', 'extendedSecurityEnvironment', 'websocketCrossOriginWhiteList', 'defaultVirtualProxy',\r\n 'tags','samlMetadataIdP', 'samlHostUri', 'samlEntityId', 'samlAttributeUserId', 'samlAttributeUserDirectory', 'samlAttributeSigningAlgorithm', 'samlAttributeMap', 'magicLinkHostUri',\r\n 'magicLinkFriendlyName','jwtPublicKeyCertificate','jwtAttributeUserDirectory','jwtAttributeMap','jwtAttributeUserId']\r\n \r\n virtualproxynodes = get_qlik_sense.get_virtualproxy()\r\n num_of_virtualproxys = len(virtualproxynodes)\r\n num_of_virtualproxy_metrics = len(virtualproxy_metrics)\r\n table = document.add_table(rows=num_of_virtualproxy_metrics+1, cols=num_of_virtualproxys+1)\r\n table.style = 'Grid Table 1 Light Accent 1'\r\n row = table.rows[0]\r\n row.cells[0].text = 'Metric'\r\n for item in range(0, num_of_virtualproxys):\r\n row.cells[item+1].text = virtualproxynodes[item][29]\r\n for item in range(num_of_virtualproxy_metrics):\r\n row = table.rows[item+1]\r\n row.cells[0].text = str(virtualproxy_metrics[item])\r\n for virtualproxynode in range(num_of_virtualproxys):\r\n row.cells[virtualproxynode+1].text = str(virtualproxynodes[virtualproxynode][item])\r\n\r\n document.add_page_break()","def get_bforce_wm_ws_Gx_surf(self):\n\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w'] \n \n self.Gm1 = np.zeros([Ly])\n self.dGm1_dS = np.zeros([Ly]) \n self.Gt1 = np.zeros([Ly])\n self.dGt1_dS = np.zeros([Ly]) \n self.Bfsfc_bl = np.zeros([Ly])\n self.Av_bl = np.zeros([Ly])\n self.dAv_bl = np.zeros([Ly])\n \n #debugging\n self.wm_surf = np.zeros([Ly])\n self.ws_surf = np.zeros([Ly]) \n\n #---> j-loop\n for j in range(Ly): \n k_w = self.kbl[j] # KBL is \"new bl index after calling find_new_kbl()\n z_bl = z_u_w[j,N] - self.hbls[j]\n zscale = self.hbls[j] \n \n if self.swr_frac[j,k_w-1] > 0:\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\n \n else:\n Bfsfc = self.Bo[j] + self.Bosol[j]\n \n # CALCUALTE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm_surf[j] = wm\n self.ws_surf[j] = ws \n\n if self.LIMIT_UNSTABLE_ONLY:\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\n else:\n f1 = 0\n\n \n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n\n #MOMENTUM \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl[j] = Av_bl\n self.dAv_bl[j] = dAv_bl\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \n\n #TEMPERATURE(BUOYANCY)\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \n\n self.Bfsfc_bl[j] = Bfsfc","def get_w(self):\n raise NotImplementedError","def propose(self):\n\n\n fb = 0.0\n changed_any = False\n\n while not changed_any:\n new = copy(self) ## Now we just copy the whole thing\n\n for w in self.all_words():\n if flip(self.propose_p):\n try:\n xp, xfb = self.get_word(w).propose()\n\n changed_any = True\n new.set_word(w, xp)\n fb += xfb\n\n except ProposalFailedException:\n pass\n\n\n return new, fb","def build_W(points):\n return None","def computeW(self):\n E = np.where(self.v > 0, 1, -1)\n # theshold the connections to only -1,1\n binary_weights = np.where(self.c > 0, 1, self.c)\n binary_weights = np.where(binary_weights < 0, -1, binary_weights)\n W = np.sum(binary_weights * np.dot(E.reshape(-1,1), E.reshape(1,-1))) # W = C * E * E\n self.W = W\n if np.sum(binary_weights) != 0:\n self.W = self.W / np.sum(binary_weights) # W / W*\n return self.W","def vcac_worklfow_request(self):\n logging.info(\"Inside ucsvm_worklfow_request method base class\")\n return None","def get_wordcloud():\n params = request.args\n result = None\n\n def set_result(x):\n nonlocal result # This is ugly, ew, gotta fix this\n result = x\n\n pipeline_zoo.get_full_word_distribution(set_result).feed_data((params, None))\n return jsonify({\n 'word_distribution': result\n })","def get_vector(word, model):\n return model.wv[word]","def new_words_only(base_words, window_words):\n new_words = []\n if base_words:\n for wword in window_words:\n dont_include = False\n for bword in base_words:\n if CharNetRunner._do_words_intersect(wword, bword):\n dont_include = True\n break\n if not dont_include:\n new_words.append(wword)\n else:\n new_words = window_words\n\n return new_words","def build_parameters(pobj):\n ViscosityWilke.build_parameters(pobj)","def search_clues(self):\r\n print(\"\\n************Searching Clues************\\n\")\r\n for word_id in self.words.keys():\r\n if not self.words[word_id].see and not self.words[word_id].wth:\r\n clue = pop_backslash(self.words[word_id].clue)\r\n temp = word_domain(\"allintext:\" + clue +' -crossword',self.words[word_id].length)\r\n temp2 = temp + word_domain(clue +' -crossword',self.words[word_id].length)\r\n domain = temp2 + data_muse(clue, self.words[word_id].length)\r\n unique_list = []\r\n for x in domain: \r\n y = x.upper()\r\n # check if exists in unique_list or not \r\n if y not in unique_list: \r\n unique_list.append(y) \r\n \r\n self.words[word_id].assign_word_domain(unique_list)\r\n print(\"\\nSearch is done...\")","def wps(model, data):\n with msg.loading(f\"Loading model '{model}'...\"):\n nlp = spacy.load(model)\n texts = (eg[\"text\"] for eg in srsly.read_jsonl(data))\n n_docs = 0\n n_words = 0\n start_time = timer()\n for doc in nlp.pipe(texts):\n n_docs += 1\n n_words += len(doc)\n end_time = timer()\n wps = int(n_words / (end_time - start_time))\n result = [\n (\"Docs\", f\"{n_docs:,}\"),\n (\"Words\", f\"{n_words:,}\"),\n (\"Words/s\", f\"{wps:,}\"),\n ]\n msg.table(result, widths=(7, 12), aligns=(\"l\", \"r\"))","def isMWS_WD(primary=None, gaia=None, galb=None, astrometricexcessnoise=None,\n pmra=None, pmdec=None, parallax=None, parallaxovererror=None,\n photbprpexcessfactor=None, astrometricsigma5dmax=None,\n gaiagmag=None, gaiabmag=None, gaiarmag=None, paramssolved=None):\n if primary is None:\n primary = np.ones_like(gaia, dtype='?')\n mws = primary.copy()\n\n # ADM do not target any objects for which entries are NaN\n # ADM and turn off the NaNs for those entries.\n if photbprpexcessfactor is not None:\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\n np.isnan(parallax) | np.isnan(photbprpexcessfactor))\n else:\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\n np.isnan(parallax))\n w = np.where(nans)[0]\n if len(w) > 0:\n parallax, gaiagmag = parallax.copy(), gaiagmag.copy()\n gaiabmag, gaiarmag = gaiabmag.copy(), gaiarmag.copy()\n if photbprpexcessfactor is not None:\n photbprpexcessfactor = photbprpexcessfactor.copy()\n # ADM safe to make these zero regardless of cuts as...\n photbprpexcessfactor[w] = 0.\n parallax[w] = 0.\n gaiagmag[w], gaiabmag[w], gaiarmag[w] = 0., 0., 0.\n # ADM ...we'll turn off all bits here.\n mws &= ~nans\n# log.info('{}/{} NaNs in file...t = {:.1f}s'\n# .format(len(w), len(mws), time()-start))\n\n # ADM apply the selection for all MWS-WD targets\n # ADM must be a Legacy Surveys object that matches a Gaia source\n mws &= gaia\n\n # ADM and all astrometric parameters are measured.\n mws &= paramssolved == 31\n\n # ADM Gaia G mag of less than 20\n mws &= gaiagmag < 20.\n\n # ADM Galactic b at least 20o from the plane\n mws &= np.abs(galb) > 20.\n\n # ADM gentle cut on parallax significance\n mws &= parallaxovererror > 1.\n\n # ADM Color/absolute magnitude cuts of (defining the WD cooling sequence):\n # ADM Gabs > 5\n # ADM Gabs > 5.93 + 5.047(Bp-Rp)\n # ADM Gabs > 6(Bp-Rp)3 - 21.77(Bp-Rp)2 + 27.91(Bp-Rp) + 0.897\n # ADM Bp-Rp < 1.7\n Gabs = gaiagmag+5.*np.log10(parallax.clip(1e-16))-10.\n br = gaiabmag - gaiarmag\n mws &= Gabs > 5.\n mws &= Gabs > 5.93 + 5.047*br\n mws &= Gabs > 6*br*br*br - 21.77*br*br + 27.91*br + 0.897\n mws &= br < 1.7\n\n # ADM Finite proper motion to reject quasars\n # ADM Inexplicably I'm getting a Runtimewarning here for\n # ADM a few values in the sqrt, so I'm catching it\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n pm = np.sqrt(pmra**2. + pmdec**2.)\n mws &= pm > 2.\n\n # ADM As of DR7, photbprpexcessfactor and astrometricsigma5dmax are not in the\n # ADM imaging catalogs. Until they are, ignore these cuts\n if photbprpexcessfactor is not None:\n # ADM remove problem objects, which often have bad astrometry\n mws &= photbprpexcessfactor < 1.7 + 0.06*br*br\n\n if astrometricsigma5dmax is not None:\n # ADM Reject white dwarfs that have really poor astrometry while\n # ADM retaining white dwarfs that only have relatively poor astrometry\n mws &= ((astrometricsigma5dmax < 1.5) |\n ((astrometricexcessnoise < 1.) & (parallaxovererror > 4.) & (pm > 10.)))\n\n return mws","def get_doc_prov(j, gcis_url, refList):\n gcis_ns = \"https://gcis-search-stage.jpl.net:3000/gcis.owl#\"\n doc = ProvEsDocument()\n bndl = None\n \n#to get people attributed to, you need to grab article -> jornal_identifier -> look up in references\n# for ref in refList:\n# if ref['child_publication'] == j['uri']:\n \n\n\n doc_attrs = [\n (\"prov:type\", 'gcis:Article'),\n (\"prov:label\", j['title']),\n (\"prov:location\", j['uri']),\n #(\"prov:wasAttributedTo\", j['']),\n ]\n doc.entity('bibo:%s' % j['identifier'], doc_attrs)\n\n prov_json = json.loads(doc.serialize())\n\n return prov_json","def test_visualize_wfe_budget():\n nrc = webbpsf.NIRCam()\n nrc.visualize_wfe_budget()","def evaluate_design(self): # to update the pr object","def getVWFile(tsvFile, vwFile, dataIndex, dictionary, tfidf_model, train=True):\r\n start = datetime.now()\r\n \r\n # extract all the index\r\n catIndex = dataIndex[\"catIndex\"]\r\n subCatIndex = dataIndex[\"subCatIndex\"]\r\n attrsKeyIndex = dataIndex[\"attrsKeyIndex\"]\r\n attrsValIndex = dataIndex[\"attrsValIndex\"]\r\n wordIndex = dataIndex[\"wordIndex\"]\r\n \r\n with open(vwFile, \"wb\") as vwWriter:\r\n with open(tsvFile, \"rb\") as tsvReader:\r\n itemReader = DictReader(tsvReader, delimiter='\\t', quotechar='\"')\r\n for i, item in enumerate(itemReader):\r\n item = {featureName:featureValue.decode('utf-8') \\\r\n for featureName,featureValue in item.items() \\\r\n if featureValue is not None}\r\n\r\n # get header\r\n itemid = int(item[\"itemid\"])\r\n label = int(item[\"is_blocked\"]) if train else 1\r\n header = \"%s '%s \" % (int(2*label - 1), itemid)\r\n \r\n # category\r\n categoryFeat = \"|C %s \" % catIndex[ item[\"category\"] ]\r\n \r\n # subcategory\r\n subcategoryFeat = \"|SC %s \" % subCatIndex[ item[\"subcategory\"] ]\r\n \r\n # title\r\n title = [ str(wordIndex[w]) for w in getWords(item[\"title\"]) ]\r\n # first-gram\r\n title_start = title[0] if len(title)>0 else \"0\"\r\n # end-gram\r\n title_end = title[-1] if len(title)>0 else \"0\"\r\n # naming is a pain for me\r\n titleFeat = \"|T %s |bT %s |cT %s \" % (\" \".join(title), title_start, title_end)\r\n titleStatsFeat = \"|t %s \" % getTextStatsFeat(item[\"title\"])\r\n \r\n # description\r\n description = [ str(wordIndex[w]) for w in getWords(item[\"description\"]) ]\r\n # first-gram\r\n description_start = description[0] if len(description)>0 else \"0\"\r\n # end-gram\r\n description_end = description[-1] if len(description)>0 else \"0\"\r\n descriptionFeat = \"|D %s |fD %s |gD %s \" % (\" \".join(description), description_start, description_end)\r\n descriptionStatsFeat = \"|d %s \" % getTextStatsFeat(item[\"description\"])\r\n tfidf_feat1 = getTfidfFeat(getUnigram(description), dictionary[1], tfidf_model[1])\r\n # 2gram tfidf seem to harm the performance, you are save to drop it here\r\n tfidf_feat2 = getTfidfFeat(getBigram(description, \"_\"), dictionary[2], tfidf_model[2])\r\n descriptionFeat += \"|iD %s |jD %s \" % (tfidf_feat1, tfidf_feat2)\r\n \r\n # attrs\r\n attrsFeat = \"\"\r\n countAttrs = 0\r\n if \"attrs\" in item:\r\n attrsDict = getAttrsDict(item[\"attrs\"])\r\n #print attrs\r\n for k,v in list(attrsDict.items()):\r\n countAttrs += 1\r\n attrsFeat += \"|A%s %s \" % (attrsKeyIndex[k], attrsValIndex[v])\r\n attrsFeat += \"|a \"\r\n for k,v in list(attrsDict.items()):\r\n attrsFeat += \"%s \" % (attrsKeyIndex[k]) \r\n if len(attrsFeat) == 0:\r\n attrsFeat = \"|NA 1 \"\r\n attrsFeat += \"|hAC %s \" % countAttrs\r\n \r\n # price\r\n priceFeat = \"|P %s \" % item[\"price\"] \r\n # phones_cnt\r\n phonesCntFeat = \"|p %s \" % item[\"phones_cnt\"]\r\n # emails_cnt\r\n emailsCntFeat = \"|e %s \" % item[\"emails_cnt\"]\r\n # urls_cnt\r\n urlsCntFeat = \"|u %s \" % item[\"urls_cnt\"]\r\n \r\n # output\r\n vwLine = header \\\r\n + categoryFeat \\\r\n + subcategoryFeat \\\r\n + titleFeat \\\r\n + titleStatsFeat \\\r\n + descriptionFeat \\\r\n + descriptionStatsFeat \\\r\n + attrsFeat \\\r\n + priceFeat \\\r\n + phonesCntFeat \\\r\n + emailsCntFeat \\\r\n + urlsCntFeat[:-1] + \"\\n\"\r\n vwWriter.write( vwLine )\r\n \r\n # report progress\r\n if (i+1)%10000 == 0:\r\n print(( \"\\n%s\\t%s\"%((i+1),str(datetime.now() - start)) ))\r\n print(( \"Sample output:\\n%s\" % vwLine ))","def check_wf(self,wf):\n pass","def geocube():","def has_wcs(self):\n return self.wcs is not None","def plotrgcloud(self):\n print self.kpunten\n for i in range(len(self.kpunten[0])):\n self.writetext('sen ='+ self.kpunten[0][i][0], (0.65,0.85), axnum = 0, hor = None ,ver = None , rot = None ,fs =14 , transform = self.fig.axes[0].transAxes)\n if i == len(self.kpunten[0]) -1 :\n end = None\n else:\n end = self.kpunten[0][i+1][1] + 1\n print end\n self.plotrgwrap( self.rgindex,2*self.reader.npair+self.rgindex,'real part of rgvars (a.u)' , 'imaginary part of rgvars (a.u.)', tit ='RG vars g = %f all states'%(self.chardata) , begin = self.kpunten[0][i][1] , stop = end , name = 'cpcloud'+ self.kpunten[0][i][0] , filenum = 0)","def newWS(self, y):\n keys=np.array(self.ImageSolution.keys())\n try:\n i=abs(keys-y).argmin()\n ws=self.ImageSolution[keys[i]]\n nws=WavelengthSolution.WavelengthSolution(ws.x_arr,ws.w_arr, order=ws.order, function=ws.function)\n nws.fit()\n return nws\n except :\n return self.ws","def calc_wvf(pedestrian, key, face, mesh_area,radius): \n normal = envuo.py3dmodel.construct.make_vector((0,0,0),envuo.py3dmodel.calculate.face_normal(face))\n surf2ped = envuo.py3dmodel.construct.make_vector(key,pedestrian)\n sa_ped = 4.0*np.pi*radius**2\n theta = normal.Angle(surf2ped)\n h = surf2ped.Magnitude()/radius \n phi = np.arctan(1/h)\n threshold = np.pi/2.0 - phi\n\n if abs(h*np.cos(theta)) > 1:\n F = abs(np.cos(theta))/h**2; \n else:\n x = np.sqrt(h**2-1)/np.tan(theta) #np.sqrt(h**2-1)\n y = np.sqrt(1-x**2) #-x/np.tan(theta) #\n F = (np.pi - abs(np.cos(x)) - x*y*np.tan(theta)**2)*abs(np.cos(theta))/(np.pi*h**2) + np.arctan(y*abs(np.cos(theta))/x)/np.pi; \n print pedestrian,' passes threshold'\n return mesh_area*F/sa_ped","def compute_RS(W):\n return None","def _vSWVT(self):\r\n\r\n logStr = \"{0:s}.{1:s}: \".format(self.__class__.__name__, sys._getframe().f_code.co_name)\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'Start.')) \r\n \r\n try: \r\n vSWVT = None\r\n vSWVT=pd.merge(self.dataFrames['SWVT'],self.dataFrames['SWVT_ROWT'],left_on='pk',right_on='fk')\r\n vSWVT['ZEIT']=pd.to_numeric(vSWVT['ZEIT']) \r\n vSWVT['W']=pd.to_numeric(vSWVT['W']) \r\n vSWVT['ZEIT_RANG']=vSWVT.groupby(['pk_x'])['ZEIT'].rank(ascending=True)\r\n #\r\n vSWVT_g=vSWVT.groupby(['pk_x'], as_index=False).agg({'W':[np.min,np.max]})\r\n vSWVT_g.columns= [tup[0]+tup[1] for tup in zip(vSWVT_g.columns.get_level_values(0),vSWVT_g.columns.get_level_values(1))]\r\n vSWVT_g.rename(columns={'Wamin':'W_min','Wamax':'W_max'},inplace=True)\r\n #\r\n vSWVT=pd.merge(vSWVT,vSWVT_g,left_on='pk_x',right_on='pk_x')\r\n #\r\n vSWVT=vSWVT[vSWVT['ZEIT_RANG']==1]\r\n #\r\n vSWVT=vSWVT[['NAME','BESCHREIBUNG','INTPOL','ZEITOPTION','W','W_min','W_max','pk_x']]\r\n #\r\n vSWVT.rename(columns={'pk_x':'pk'},inplace=True)\r\n \r\n except Exception as e:\r\n logStrFinal=\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\r\n logger.error(logStrFinal) \r\n raise XmError(logStrFinal) \r\n finally:\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'_Done.'))\r\n return vSWVT","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',\n verbose=False))\n # No NaNs are supposed to be in the output.\n self.assertEqual(np.isnan(wv).any(), False)\n rms1 = rms(rec['wv_250_500_25'], wv[250:500:25])\n rms2 = rms(rec['wv_750_1000_25'], wv[750:1000:25])\n self.assertEqual(True, rms1 < 1e-6)\n self.assertEqual(True, rms2 < 1e-6)","def test_slpi_cwro(self):\r\n\t\twith open(\"test_slpi_cwro.txt\", \"w\") as test_slpi_cwro_output:\r\n\t\t\tsys.stdout = test_slpi_cwro_output # Redirect print in censor to temporary output file\r\n\t\t\t# Appropriate censor function call\r\n\t\t\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=1, censor_words_one_pass=True)\r\n\t\twith open(\"test_slpi_cwro.txt\", \"r\") as test_slpi_cwro_output:\r\n\t\t\twhile True:\r\n\t\t\t\t# Assert every output line in file matches the expected output\r\n\t\t\t\tline_output = test_slpi_cwro_output.readline()\r\n\t\t\t\tline_correct = cc_test_prose.readline()\r\n\t\t\t\tself.assertEqual(line_output, line_correct)\r\n\t\t\t\tif line_correct == '': # Stop reading expected output at eof\r\n\t\t\t\t\tbreak\r\n\t\tcc_test_prose.seek(0) # Reset read head in expected output file\r\n\t\tsys.stdout = sys.__stdout__ # Reset stdout redirection\r\n\t\tos.remove(\"test_slpi_cwro.txt\") # Delete temporary output file if test is successful\r","def collecte_docs(self, chercheur, overwrite=False): # self,\n init = overwrite # If True, data persistence is lost when references are updated\n docs = hal.find_publications(chercheur[\"halId_s\"], \"authIdHal_s\")\n\n progress_recorder = ProgressRecorder(self)\n progress_recorder.set_progress(0, len(docs), description=\"récupération des données HAL\")\n # Insert documents collection\n for num, doc in enumerate(docs):\n doc[\"country_colaboration\"] = location_docs.generate_countrys_fields(doc)\n doc = doi_enrichissement.docs_enrichissement_doi(doc)\n if \"fr_abstract_s\" in doc.keys():\n if isinstance(doc[\"fr_abstract_s\"], list):\n doc[\"fr_abstract_s\"] = \"/n\".join(doc[\"fr_abstract_s\"])\n if len(doc[\"fr_abstract_s\"]) > 100:\n doc[\"fr_entites\"] = keyword_enrichissement.return_entities(\n doc[\"fr_abstract_s\"], \"fr\"\n )\n doc[\"fr_teeft_keywords\"] = keyword_enrichissement.keyword_from_teeft(\n doc[\"fr_abstract_s\"], \"fr\"\n )\n if \"en_abstract_s\" in doc.keys():\n if isinstance(doc[\"en_abstract_s\"], list):\n doc[\"en_abstract_s\"] = \"/n\".join(doc[\"en_abstract_s\"])\n if len(doc[\"en_abstract_s\"]) > 100:\n doc[\"en_entites\"] = keyword_enrichissement.return_entities(\n doc[\"en_abstract_s\"], \"en\"\n )\n doc[\"en_teeft_keywords\"] = keyword_enrichissement.keyword_from_teeft(\n doc[\"en_abstract_s\"], \"en\"\n )\n\n doc[\"_id\"] = doc[\"docid\"]\n doc[\"validated\"] = True\n\n doc[\"harvested_from\"] = \"researcher\"\n\n doc[\"harvested_from_ids\"] = []\n doc[\"harvested_from_label\"] = []\n\n #\n #\n # print(doc[\"authorship\"], doc ['authLastName_s'])\n\n if len(doc[\"authIdHal_s\"]) != len(doc[\"authLastName_s\"]):\n # print (\"elastichal.py : test d'autorat no good\")\n # test sur le nom complet...\n nom = [\n truc\n for truc in doc[\"authLastName_s\"]\n if chercheur[\"lastName\"].lower() in truc.lower()\n ] # pour les récemment mariés qui auraient un nom composé...\n # Après si 'lun des co-auteur porte le même nom...\n if len(nom) > 0:\n nom = nom[0].title()\n try:\n if doc[\"authLastName_s\"].index(nom) == 0: # premier\n doc[\"authorship\"] = [\n {\"authorship\": \"firstAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n elif (\n doc[\"authLastName_s\"].index(nom) == len(doc[\"authLastName_s\"]) - 1\n ): # dernier\n doc[\"authorship\"] = [\n {\"authorship\": \"lastAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n except ValueError:\n doc[\"authorship\"] = []\n else:\n doc[\"authorship\"] = []\n elif chercheur[\"halId_s\"] in doc[\"authIdHal_s\"]:\n if doc[\"authIdHal_s\"].index(chercheur[\"halId_s\"]) == 0:\n doc[\"authorship\"] = [\n {\"authorship\": \"firstAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n elif (\n doc[\"authIdHal_s\"].index(chercheur[\"halId_s\"]) == len(doc[\"authIdHal_s\"]) - 1\n ): # dernier\n doc[\"authorship\"] = [\n {\"authorship\": \"lastAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n else:\n doc[\"authorship\"] = []\n else:\n doc[\"authorship\"] = []\n\n doc[\"harvested_from_ids\"].append(chercheur[\"halId_s\"])\n\n # historique d'appartenance du docId\n # pour attribuer les bons docs aux chercheurs\n # harvet_history.append({'docid': doc['docid'], 'from': row['halId_s']})\n #\n # for h in harvet_history:\n # if h['docid'] == doc['docid']:\n # if h['from'] not in doc[\"harvested_from_ids\"]:\n # doc[\"harvested_from_ids\"].append(h['from'])\n\n doc[\"records\"] = []\n\n doc[\"MDS\"] = utils.calculate_mds(doc)\n\n try:\n should_be_open = utils.should_be_open(doc)\n if should_be_open == 1:\n doc[\"should_be_open\"] = True\n if should_be_open == -1:\n doc[\"should_be_open\"] = False\n\n if should_be_open == 1 or should_be_open == 2:\n doc[\"isOaExtra\"] = True\n elif should_be_open == -1:\n doc[\"isOaExtra\"] = False\n except IndexError:\n print(\"publicationDate_tdate error ?\")\n doc[\"Created\"] = datetime.datetime.now().isoformat()\n\n if not init: # récupération de l'existant pour ne pas écraser\n field = \"_id\"\n doc_param = esActions.scope_p(field, doc[\"_id\"])\n\n if not es.indices.exists(\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\"\n ): # -researchers\" + row[\"ldapId\"] + \"-documents\n print(\"exception \", chercheur[\"labHalId\"], chercheur[\"ldapId\"])\n\n res = es.search(\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\",\n body=doc_param,\n ) # -researchers\" + row[\"ldapId\"] + \"-documents\n\n if len(res[\"hits\"][\"hits\"]) > 0:\n doc[\"validated\"] = res[\"hits\"][\"hits\"][0][\"_source\"][\"validated\"]\n if \"authorship\" in res[\"hits\"][\"hits\"][0][\"_source\"]:\n doc[\"authorship\"] = res[\"hits\"][\"hits\"][0][\"_source\"][\"authorship\"]\n\n if (\n res[\"hits\"][\"hits\"][0][\"_source\"][\"modifiedDate_tdate\"]\n != doc[\"modifiedDate_tdate\"]\n ):\n doc[\"records\"].append(\n {\n \"beforeModifiedDate_tdate\": doc[\"modifiedDate_tdate\"],\n \"MDS\": res[\"hits\"][\"hits\"][0][\"_source\"][\"MDS\"],\n }\n )\n\n else:\n doc[\"validated\"] = True\n progress_recorder.set_progress(num, len(docs), description=\"(récolte)\")\n progress_recorder.set_progress(num, len(docs), description=\"(indexation)\")\n helpers.bulk(\n es,\n docs,\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\",\n refresh=\"wait_for\",\n )\n\n return chercheur # au cas où","def exposedSurf(self):\n if self.precision:\n h = self.evaluations.exposedWing.edges[1].point1.x # height of trapezoid\n B = self.chordRootW # major base of trapezoid\n b = self.evaluations.chordIntersected.edges[1].length # minor base of trapezoid\n internalS = 2 * (0.5 * (b + B) * h) # wing surface internal at fuselage\n return self.surfaceW - internalS\n else:\n return self.surfaceW - self.fuselageDiameter * self.cMACW # first guess for a faster evaluation","def v(w,s):\n return w","def init_ngrams(self):\n self.wv.ngrams = {}\n all_ngrams = []\n self.wv.syn0 = np.zeros((len(self.wv.vocab), self.vector_size), dtype=REAL)\n\n for w, vocab in self.wv.vocab.items():\n all_ngrams += compute_ngrams(w, self.wv.min_n, self.wv.max_n)\n self.wv.syn0[vocab.index] += np.array(self.wv.syn0_ngrams[vocab.index])\n\n all_ngrams = set(all_ngrams)\n self.num_ngram_vectors = len(all_ngrams)\n ngram_indices = []\n for i, ngram in enumerate(all_ngrams):\n ngram_hash = ft_hash(ngram)\n ngram_indices.append(len(self.wv.vocab) + ngram_hash % self.bucket)\n self.wv.ngrams[ngram] = i\n self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)\n\n ngram_weights = self.wv.syn0_ngrams\n\n logger.info(\n \"loading weights for %s words for fastText model from %s\",\n len(self.wv.vocab), self.file_name\n )\n\n for w, vocab in self.wv.vocab.items():\n word_ngrams = compute_ngrams(w, self.wv.min_n, self.wv.max_n)\n for word_ngram in word_ngrams:\n self.wv.syn0[vocab.index] += np.array(ngram_weights[self.wv.ngrams[word_ngram]])\n\n self.wv.syn0[vocab.index] /= (len(word_ngrams) + 1)\n logger.info(\n \"loaded %s weight matrix for fastText model from %s\",\n self.wv.syn0.shape, self.file_name\n )","def stop_word(w): # local feature\n return (w in swl)","def compare_wavs_length(c_wv, s_wv):\n\n # If the style wav is shorter than the content wav, exit in error\n if s_wv.shape[0] < c_wv.shape[0]:\n raise WavError(\"The style wav must be as long or longer than the content wav\")\n\n # If the style wav is longer, truncate it to match the content length\n elif s_wv.shape[0] > c_wv.shape[0]:\n print(\"Truncating style wav to match content wav length\")\n s_wv = np.copy(s_wv[:c_wv.shape[0],:])\n\n return s_wv","def build_vocab(self, corpus):\n if self.vocabulary_counts != None:\n logger.debug(\"building vocabulary from provided frequency map\")\n vocab = self.vocabulary_counts\n else:\n logger.debug(\"default vocabulary building\")\n super(Skipgram, self).build_vocab(corpus)\n return\n\n # assign a unique index to each word\n self.vocab, self.index2word = {}, []\n\n for word, count in vocab.iteritems():\n v = Vocab()\n v.count = count\n if v.count >= self.min_count:\n v.index = len(self.vocab)\n self.index2word.append(word)\n self.vocab[word] = v\n\n logger.debug(\"total %i word types after removing those with count<%s\" % (len(self.vocab), self.min_count))\n\n if self.hs:\n # add info about each word's Huffman encoding\n self.create_binary_tree()\n if self.negative:\n # build the table for drawing random words (for negative sampling)\n self.make_table()\n # precalculate downsampling thresholds\n self.precalc_sampling()\n self.reset_weights()","def calc_doc_ret_MAP():\n \n# docs_norm_scores_dicts_path = linux_base_path+\"/docs_norm_scores_dicts\"\n claim_rel_docno_dict = read_pickle(\"claim_rel_docno_dict\") #key is clm, value is a set of the relevant docno\n# nDCG_MAP_res = base_path +\"\\\\nDCG_MAP_res\\\\\"\n# docs_norms_path = base_path+\"\\\\docs_norm_scores_dicts\\\\\"\n docs_norms_path = linux_base_path+\"/docs_norm_scores_dicts/\"\n nDCG_MAP_res = linux_base_path +\"/nDCG_MAP_res/\"\n \n AP_cut_off = 1000\n k_val = 100\n p = 10\n log = open(\"calc_doc_avg_nDCG_MAP_log_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),\"wb\")\n res_file = open(nDCG_MAP_res+\"doc_ret_nDCG_MAP_res_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),\"wb\")\n# each_params_AVGnDCG_MAP_dict = {} #key is alpha,beta,k_docs,lambda and val is the avg nDCG and MAP across all claims together\n each_params_MAP_dict = {}\n# NDCG_AP_all_claims_all_param_values = {}\n AP_all_claims_all_param_values = {}\n best_avg_nDCG = 0\n best_MAP = 0 #across all claims in a given configuration, find the max measures\n \n# docs_norms_path = base_path+\"\\\\docs_norm_scores_dicts\\\\\"\n claims_dict = read_pickle(\"claim_dict\")\n #count the number of sentences that were retrived that are in the true data....sum for each claim, then average.\n \n \n for alpha in range(0,11,1): #change just for test!\n for beta in range(0,10,1):\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\n NDCG_all_claims= {} #key is a claim, value is the nDCG\n AP_all_claims= {} \n AP_cut_off = 1000\n curr_filename = docs_norms_path+\"clm_key_ranked_list_of_docs_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)\n clm_key_ranked_list_of_docs_baseline = read_pickle(curr_filename) #key is qID and docid\n #need to turn it to a list of docs\n for clm in claim_list:\n try:\n# nDCG_score = utils_linux.calc_doc_emp_NDCG(curr_source,str(clm),clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]],p)\n# NDCG_all_claims[clm] = nDCG_score\n AP_score = utils_linux.calc_doc_AP_relevance(AP_cut_off,curr_source,clm,clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]])\n AP_all_claims[clm] = AP_score\n AP_all_claims_all_param_values[clm,alpha_f,beta_f,k_val] = AP_score\n except Exception as err: \n log.write('problem in calculations: in source: '+ curr_source+' in clm '+ claims_dict[str(clm)]+\" alpha:\"+str(alpha_f)+ \"beta:\"+str(beta_f)+\" \\n\" ) \n for arg in err.args:\n log.write(arg+\" \") \n log.write(\"\\n\") \n# average_NDCG = float(float(sum(NDCG_all_claims.values()))/float(len(NDCG_all_claims))) #across all claims...\n# if average_NDCG > best_avg_nDCG:\n# best_avg_nDCG = average_NDCG\n# best_avg_nDCG_configuration = (alpha_f,beta_f,k_val)\n MAP = float(float(sum(AP_all_claims.values()))/float(len(AP_all_claims)))\n if MAP > best_MAP:\n best_MAP = MAP\n best_MAP_configuration = (alpha_f,beta_f,k_val)\n each_params_MAP_dict[alpha_f,beta_f,k_val] = MAP\n utils_linux.save_pickle(nDCG_MAP_res+\"doc_ret_NDCG_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"_at_\"+str(p),NDCG_all_claims)\n utils_linux.save_pickle(nDCG_MAP_res+\"doc_ret_AP_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val),AP_all_claims)\n# res_file.write(\"alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"|\"+\"AnDCG_\"+str(average_NDCG)+\"_MAP_\"+str(MAP)+\"\\n\")\n res_file.write(\"alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"|_MAP_\"+str(MAP)+\"\\n\")\n save_pickle(nDCG_MAP_res+\"doc_ret_NDCG_AP_all_claims_all_param_values_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),AP_all_claims_all_param_values)\n save_pickle(nDCG_MAP_res+\"doc_ret_each_params_AVGnDCG_MAP_dict_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),each_params_MAP_dict)\n# best_row = \"best_avg_nDCG|\"+str(best_avg_nDCG)+\"|best_avg_nDCG_configuration|\"+str(best_avg_nDCG_configuration[0])+\",\"+str(best_avg_nDCG_configuration[1])+\",\"+str(best_avg_nDCG_configuration[3])+\",\"+str(best_avg_nDCG_configuration[2])+\"|\"\n best_row = \"best_MAP|\" +str(best_MAP)+\"|best_MAP_configuration|\"+str(best_MAP_configuration[0])+\",\"+str(best_MAP_configuration[1])+\",\"+str(best_MAP_configuration[2])\n res_file.write(best_row)\n res_file.close()\n log.close()","def documento():\r\n\tpass","def qwf(self, vw, ev, gp, psi_l, lai, dt):\n\t\t#if the amount of water in storage is less than amount that will be absorbed by plant in timestep dt, then what's left will be absorbed \n\t qw = (self.gwf(self.psi_wf(self.vw,self.d1, self.d1, self.ns, self.tl), self.H, self.J)*(self.psi_wf(self.vw, self.d1, self.d1, self.ns, self.tl) - (ev*(1. - self.F_CAP))/(lai*gp) - psi_l)*lai)\n\t if self.vw == 0:\n\t return 0.\n\t elif self.vw*10**6 <= qw*dt:\n\t return (self.vw*10**6/dt)\n\t else:\n\t return qw","def _compute_export_in_woo(self):\n for rec in self:\n rec.ks_export_in_woo = bool(rec.ks_woo_id)","def test_continue_build() -> None:\n tknzr = WsTknzr(is_uncased=True, max_vocab=-1, min_count=0)\n tknzr.build_vocab(['a'])\n tknzr.build_vocab(['b'])\n tknzr.build_vocab(['c'])\n assert tknzr.tk2id == {\n BOS_TK: BOS_TKID,\n EOS_TK: EOS_TKID,\n PAD_TK: PAD_TKID,\n UNK_TK: UNK_TKID,\n 'a': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 1,\n 'b': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 2,\n 'c': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 3,\n }","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def evaluate():\n global dictionary, wv\n count = 0\n # To save the scores by distance and similarity\n scores = np.zeros(6)\n similar = np.zeros(6)\n itr = len(dictionary)\n logging.info('running evaluation for {0} samples'.format(itr))\n for key in dictionary:\n progress = (count / itr) * 100\n d = dictionary[key].split('resource/')\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\n try:\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\n dtype=np.float32)\n except KeyError:\n itr -= 1\n continue\n if np.any(np.isnan(r)):\n itr -= 1\n continue\n else:\n if r.ndim == 2:\n try:\n # Mean of vector containing all word vectors\n # obtained from abstract.\n r = r.mean(axis=0).reshape(1, -1)\n \n # Obtain the vectors for the entity\n mean_vec = mean_encoder(dictionary[key])\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\n mean_dist_vec = distance_encoder(dictionary[key])\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\n title_vec = title_mean(key)\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\n abstract_vec = abstract_encoder(key)\n abstract_vec = abstract_vec.reshape(1, -1)\n abstract_vec = abstract_vec / norm(abstract_vec)\n random_vec = np.random.randn(100).reshape(1, -1)\n zero_vec = np.zeros(100).reshape(1, -1)\n \n # Score the entity vectors\n scores[0] += norm(r - mean_vec)\n scores[1] += norm(r - mean_dist_vec)\n scores[2] += norm(r - title_vec)\n scores[3] += norm(r - abstract_vec)\n scores[4] += norm(r - random_vec)\n scores[5] += norm(r - zero_vec)\n similar[0] += cosine_similarity(r, mean_vec)\n similar[1] += cosine_similarity(r, mean_dist_vec)\n similar[2] += cosine_similarity(r, title_vec)\n similar[3] += cosine_similarity(r, abstract_vec)\n similar[4] += cosine_similarity(r, random_vec)\n similar[5] += cosine_similarity(r, zero_vec)\n count += 1\n print(count, end='\\r')\n except (ValueError, KeyError) as _:\n itr -= 1\n continue\n else:\n itr -= 1\n continue\n # Normalize the scores to get a better\n # comparison against the baselines.\n scores = scores / norm(scores)\n similar = similar / norm(similar)\n print_summary(scores, similar)","def _derW(self, w, x, y, z):\n if _isscalar(w):\n w_pos = max(min(self.wSearchFunc(self.w_list, w), self.w_n - 1), 1)\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\n else:\n w_pos = self.wSearchFunc(self.w_list, w)\n w_pos[w_pos < 1] = 1\n w_pos[w_pos > self.w_n - 1] = self.w_n - 1\n x_pos = self.xSearchFunc(self.x_list, x)\n x_pos[x_pos < 1] = 1\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\n y_pos = self.ySearchFunc(self.y_list, y)\n y_pos[y_pos < 1] = 1\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n z_pos = self.zSearchFunc(self.z_list, z)\n z_pos[z_pos < 1] = 1\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\n i = w_pos # for convenience\n j = x_pos\n k = y_pos\n l = z_pos\n beta = (x - self.x_list[j - 1]) / (self.x_list[j] - self.x_list[j - 1])\n gamma = (y - self.y_list[k - 1]) / (self.y_list[k] - self.y_list[k - 1])\n delta = (z - self.z_list[l - 1]) / (self.z_list[l] - self.z_list[l - 1])\n dfdw = (\n (\n (1 - beta)\n * (1 - gamma)\n * (1 - delta)\n * self.f_values[i, j - 1, k - 1, l - 1]\n + (1 - beta) * (1 - gamma) * delta * self.f_values[i, j - 1, k - 1, l]\n + (1 - beta) * gamma * (1 - delta) * self.f_values[i, j - 1, k, l - 1]\n + (1 - beta) * gamma * delta * self.f_values[i, j - 1, k, l]\n + beta * (1 - gamma) * (1 - delta) * self.f_values[i, j, k - 1, l - 1]\n + beta * (1 - gamma) * delta * self.f_values[i, j, k - 1, l]\n + beta * gamma * (1 - delta) * self.f_values[i, j, k, l - 1]\n + beta * gamma * delta * self.f_values[i, j, k, l]\n )\n - (\n (1 - beta)\n * (1 - gamma)\n * (1 - delta)\n * self.f_values[i - 1, j - 1, k - 1, l - 1]\n + (1 - beta)\n * (1 - gamma)\n * delta\n * self.f_values[i - 1, j - 1, k - 1, l]\n + (1 - beta)\n * gamma\n * (1 - delta)\n * self.f_values[i - 1, j - 1, k, l - 1]\n + (1 - beta) * gamma * delta * self.f_values[i - 1, j - 1, k, l]\n + beta\n * (1 - gamma)\n * (1 - delta)\n * self.f_values[i - 1, j, k - 1, l - 1]\n + beta * (1 - gamma) * delta * self.f_values[i - 1, j, k - 1, l]\n + beta * gamma * (1 - delta) * self.f_values[i - 1, j, k, l - 1]\n + beta * gamma * delta * self.f_values[i - 1, j, k, l]\n )\n ) / (self.w_list[i] - self.w_list[i - 1])\n return dfdw","def _get_context_from_gdoc(self, key):\n try:\n content = self.export_xlsx(key)\n data = process_xlsx(content)\n if 'values' in data:\n data = copy_global_values(data)\n return data\n except BadStatusLine:\n # Stale connection, reset API and data\n puts(\"Connection reset, reloading drive API\")\n self.client = get_drive_api()\n return self._get_context_from_gdoc(key)","def test_validate_wc3(self):\r\n assert self.wc2_tree != 0","def w(self): # pylint: disable=invalid-name\n return self._w","def vwf(self, vw, ev, gp, psi_l, lai, dt):\n\t return min(vw - self.qwf(self.vw, self.th, self.gp, self.psi_l, self.LAI, dt)*dt/10.**6, self.ZW)","def processVS(self, model=\"okapi\", l = 0.5):\n self.results[model] = {}\n for query in self.queries:\n res = {}\n for doc in query.docs.values():\n sum_otf = 0.0\n for term in doc.terms:\n if model == \"okapi\":\n sum_otf += self.okapiTF(term.tf, doc.dlen, self.avgdlen)\n if model == \"tfidf\":\n sum_otf += self.tfidf(term.tf, term.df, doc.dlen, self.avgdlen, self.num_docs)\n if model == \"bm25\":\n sum_otf += self.bm25(term.tf, term.df, query.query_tf[term.term], doc.dlen, self.avgdlen, self.num_docs)\n res[doc.id] = sum_otf\n self.results[model][query.id] = res","def computeProportionWings(self):\n self.ws_me_pointsA = []\n self.ws_me_pointsIy = []\n self.ws_me_pointsIz = []\n self.ws_me_pointsJ = []\n for i in range(self.nWings):\n wingIndex = i+1\n wingNnodes = self.settings[\"wing\"+str(wingIndex)][\"FEM\"][\"nodesFEM\"]\n if self.tigl.wingGetSymmetry(i+1) != 0:\n wingNnodes = 2*wingNnodes - 1\n inputMaxA = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"A\"]\n inputMaxIy = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"Iy\"]\n inputMaxIz = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"Iz\"]\n inputMaxJ = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"J\"]\n inputInterpolationType = self.settings[\"wing\"+str(wingIndex)][\"FEM\"][\"mechanicalInterpolationType\"]\n index = np.argmax(self.ws_me_pointsInitArea[i])\n wingMaxArea = self.ws_me_pointsInitArea[i][index]\n\n if inputInterpolationType == \"constant\":\n exposant = 0\n elif inputInterpolationType == \"linear\":\n exposant = 1\n elif inputInterpolationType == \"quadratic\":\n exposant = 2\n else:\n logger.error(\"Wing mechanical properties distribution is\")\n logger.error(\"wrong. Accepted values are \\\"constant\\\",\")\n logger.error(\"\\\"linear\\\", \\\"quadratic\\\"\")\n sys.exit()\n\n coef = np.empty(wingNnodes)\n self.w_m_pointsA = np.empty(wingNnodes)\n self.w_m_pointsIy = np.empty(wingNnodes)\n self.w_m_pointsIz = np.empty(wingNnodes)\n self.w_m_pointsJ = np.empty(wingNnodes)\n for j in range(wingNnodes):\n coef[j] = self.ws_me_pointsInitArea[i][j]/wingMaxArea\n self.w_m_pointsA[j] = inputMaxA * coef[j]\n self.w_m_pointsIy[j] = inputMaxIy * coef[j]**exposant\n self.w_m_pointsIz[j] = inputMaxIz * coef[j]**exposant\n self.w_m_pointsJ[j] = inputMaxJ * coef[j]**exposant\n self.ws_me_pointsA.append(self.w_m_pointsA)\n self.ws_me_pointsIy.append(self.w_m_pointsIy)\n self.ws_me_pointsIz.append(self.w_m_pointsIz)\n self.ws_me_pointsJ.append(self.w_m_pointsJ)","def unknown(self, w):\n return True","def generate_wordcloud():\r\n # \"\"\"Join list into one string\"\"\"\r\n # unique_string = (\" \").join(prioritized)\r\n # wc = WordCloud(background_color=\"black\", width=2000, height=2000,contour_color=\"black\", max_words=30, relative_scaling=0.5, normalize_plurals=False).generate(unique_string)\r\n\r\n \"\"\"Generate word cloud based on dictionary\"\"\"\r\n wc = WordCloud(background_color=\"black\", width=2000, height=2000, contour_color=\"black\", max_words=30,\r\n relative_scaling=0.5, normalize_plurals=False).generate_from_frequencies(priority_dict)\r\n\r\n fig = plt.figure(figsize=(10, 7))\r\n fig.suptitle(\"Top 30 Most Visited Websites\")\r\n plt.imshow(wc, interpolation=\"bilinear\")\r\n plt.axis(\"on\")\r\n plt.show()","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 w(self):\n return self._w","def filter_w2v_nomenclature(w2vfilename,filter_nomenclature):\n V = set(filter_nomenclature)\n wordlist = []\n veclist = [] \n istream = open(w2vfilename)\n istream.readline() #skips w2v header\n for line in istream:\n fields = line.split()\n word = fields[0]\n if word in V:\n vec = np.array([float(elt) for elt in fields[1:]])\n wordlist.append(word)\n veclist.append(vec)\n istream.close()\n M = np.array(veclist)\n return (wordlist,M)","def __init__(self, w0=6):\n self.w0 = w0\n if w0 == 6:\n # value of C_d from TC98\n self.C_d = 0.776"],"string":"[\n \"def get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode):\\r\\n cnt_list =[]\\r\\n for b, g_wc1 in enumerate(g_wc):\\r\\n pr_wn1 = len(pr_sql_i[b][\\\"conds\\\"])\\r\\n g_wn1 = g_wn[b]\\r\\n\\r\\n # Now sorting.\\r\\n # Sort based wc sequence.\\r\\n if mode == 'test':\\r\\n idx1 = argsort(array(g_wc1))\\r\\n elif mode == 'train':\\r\\n idx1 = list( range( g_wn1) )\\r\\n else:\\r\\n raise ValueError\\r\\n\\r\\n if g_wn1 != pr_wn1:\\r\\n cnt_list.append(0)\\r\\n continue\\r\\n else:\\r\\n flag = True\\r\\n for i_wn, idx11 in enumerate(idx1):\\r\\n g_wvi_str11 = str(g_sql_i[b][\\\"conds\\\"][idx11][2]).lower()\\r\\n pr_wvi_str11 = str(pr_sql_i[b][\\\"conds\\\"][i_wn][2]).lower()\\r\\n # print(g_wvi_str11)\\r\\n # print(pr_wvi_str11)\\r\\n # print(g_wvi_str11==pr_wvi_str11)\\r\\n if g_wvi_str11 != pr_wvi_str11:\\r\\n flag = False\\r\\n # print(g_wv1, g_wv11)\\r\\n # print(pr_wv1, pr_wv11)\\r\\n # input('')\\r\\n break\\r\\n if flag:\\r\\n cnt_list.append(1)\\r\\n else:\\r\\n cnt_list.append(0)\\r\\n\\r\\n return cnt_list\",\n \"def _compute_wo(self):\\n self.uom_id = self.wo_id.uom_id.id\\n self.final_product_id = self.wo_id.final_product_id.id\\n if not self.supplier_id:\\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\\n else:\\n service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\\n if service_ids:\\n product_supp_rcs = self.env['product.supplierinfo'].search([('partner_id', '=', self.supplier_id.id), ('product_id', 'in', service_ids)])\\n if product_supp_rcs:\\n product_ids = [x.product_id.id for x in product_supp_rcs if x.product_id]\\n else:\\n product_ids = []\\n else:\\n product_ids = [] \\n \\n self.service_ids = product_ids\\n \\n # Permet de savoir si l'OT suivant est de sous-traitance et qu'il y a qu'un seul OT suivant\\n no_direct_fp = True\\n if self.wo_id.next_wo_ids and len(self.wo_id.next_wo_ids) == 1 and self.wo_id.next_wo_ids[0].is_subcontracting and self.wo_id.next_wo_ids[0].consumed_service_ids:\\n no_direct_fp = False\\n \\n self.no_direct_fp = no_direct_fp\",\n \"def convert_pr_wvi_to_string(pr_wvi, nlu_t, nlu_wp_t, wp_to_wh_index, nlu):\\r\\n pr_wv_str_wp = [] # word-piece version\\r\\n pr_wv_str = []\\r\\n for b, pr_wvi1 in enumerate(pr_wvi):\\r\\n pr_wv_str_wp1 = []\\r\\n pr_wv_str1 = []\\r\\n wp_to_wh_index1 = wp_to_wh_index[b]\\r\\n nlu_wp_t1 = nlu_wp_t[b]\\r\\n nlu_t1 = nlu_t[b]\\r\\n\\r\\n for i_wn, pr_wvi11 in enumerate(pr_wvi1):\\r\\n st_idx, ed_idx = pr_wvi11\\r\\n\\r\\n # Ad-hoc modification of ed_idx to deal with wp-tokenization effect.\\r\\n # e.g.) to convert \\\"butler cc (\\\" ->\\\"butler cc (ks)\\\" (dev set 1st question).\\r\\n pr_wv_str_wp11 = nlu_wp_t1[st_idx:ed_idx+1]\\r\\n pr_wv_str_wp1.append(pr_wv_str_wp11)\\r\\n\\r\\n st_wh_idx = wp_to_wh_index1[st_idx]\\r\\n ed_wh_idx = wp_to_wh_index1[ed_idx]\\r\\n pr_wv_str11 = nlu_t1[st_wh_idx:ed_wh_idx+1]\\r\\n\\r\\n pr_wv_str1.append(pr_wv_str11)\\r\\n\\r\\n pr_wv_str_wp.append(pr_wv_str_wp1)\\r\\n pr_wv_str.append(pr_wv_str1)\\r\\n\\r\\n return pr_wv_str, pr_wv_str_wp\",\n \"def unknown(self, w):\\n # WORK HERE!!\",\n \"def _compute_wo(self):\\n self.uom_id = self.wo_id.uom_id.id\\n self.final_product_id = self.wo_id.final_product_id.id\\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\",\n \"def get_wm_ws_Gx_bot(self):\\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \\n z_u_r = self.grid_dict['z_u_r']\\n z_u_w = self.grid_dict['z_u_w']\\n [Ly,N] = self.b.shape\\n #---> j-loop\\n for j in range(Ly): \\n self.kbl[j] = N # initialize search\\n #-> end j-loop\\n\\n #--> k-loop\\n for k in range(N-1,0,-1):\\n k_w = k\\n k_r = k-1\\n # --> j loop \\n for j in range(Ly):\\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\\n self.kbl[j] = k_w\\n\\n #--> end k\\n # --> end j\\n\\n\\n '''\\n Compute nondimenisonal shape function coefficeints Gx() by\\n matching values and vertical derivatives of interior mixing\\n coefficients at hbbl (sigma=1)\\n '''\\n\\n self.Gm1_bot = np.zeros([Ly])\\n self.dGm1_dS_bot = np.zeros([Ly])\\n self.Gt1_bot = np.zeros([Ly])\\n self.dGt1_dS_bot = np.zeros([Ly]) \\n self.Av_bl_bot = np.zeros([Ly])\\n self.dAv_bl_bot = np.zeros([Ly]) \\n self.cff_up_bot = np.zeros([Ly])\\n self.cff_dn_bot = np.zeros([Ly])\\n\\n\\n\\n\\n\\n self.wm_bot = np.zeros([Ly])\\n self.ws_bot = np.zeros([Ly]) \\n\\n # CALCULATE ustar for the bottom based on bototm velocities\\n \\n \\n \\n # CALCULATE r_D\\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \\n u = self.u\\n v_upts = TTTW_func.v2u(self.v)\\n \\n ubar = np.mean(u,axis=1)\\n vbar = np.mean(v_upts,axis=1)\\n\\n # --> j loop\\n for j in range(Ly):\\n # turbulent velocity sclaes with buoyancy effects neglected\\n if self.CD_SWITCH:\\n # DEPTH AVERAGED APPROACH\\n uref = u[j,0]\\n vref = v_upts[j,0]\\n ustar2 = self.C_D * (uref**2 + vref**2)\\n else:\\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\\n wm = self.vonKar * np.sqrt(ustar2)\\n ws = wm\\n\\n self.wm_bot[j] = wm\\n self.ws_bot[j] = ws\\n \\n k_w = self.kbl[j] \\n z_bl = z_u_w[j,0] + self.hbbl[j]\\n\\n if z_bl < z_u_w[j,k_w-1]:\\n k_w = k_w-1\\n\\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl_bot[j] = Av_bl\\n self.dAv_bl_bot[j] = dAv_bl\\n\\n\\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\\n\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])\",\n \"def grounding_words(self, w):\\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])\",\n \"def wisdom(search_me, source, pdfurl, userid):\\n ### source needs to be name of data source (\\\"arxiv\\\", \\\"google scholar\\\", \\\"doaj\\\")\\n search_me = search_me.strip()\\n # check if pdfurl has been found before\\n pdf = db_summaries.find_one({\\\"url\\\": pdfurl})\\n if pdf:\\n text = pdf.get('text')\\n summary = pdf.get('summary')\\n topics = pdf.get('topics')\\n # update in db if data is 1 days or older\\n last_updated = datetime.utcnow() - pdf.get(\\\"last_updated\\\")\\n last_updated_diff = last_updated.days\\n if last_updated_diff > 1:\\n search_term = db_search_terms.find_one({\\\"value\\\": search_me.lower()})\\n search_id = search_term.get(\\\"_id\\\")\\n data = {\\\"search_id\\\": search_id,\\n \\\"url\\\": pdfurl, \\\"source\\\": source, \\\"text\\\": text,\\n \\\"summary\\\": summary, \\\"topics\\\": topics, \\\"last_updated\\\": datetime.utcnow()}\\n db_summaries.update({\\\"url\\\": pdfurl}, {\\\"$set\\\": data})\\n else:\\n pass\\n else:\\n text = wisdomaiengine.pdfdocumentextracter(pdfurl)\\n summary = wisdomaiengine.summarisepdfdocument(text)\\n topics = wisdomaiengine.wordcloud(search_me, text)\\n if topics is None:\\n topics = ['No Topics Found']\\n # write data to arxiv collection\\n search_term = db_search_terms.find_one({\\\"value\\\": search_me.lower()})\\n search_id = search_term.get(\\\"_id\\\")\\n data = {\\\"search_id\\\": search_id,\\n \\\"url\\\": pdfurl,\\n \\\"source\\\": source,\\n \\\"text\\\": text,\\n \\\"summary\\\": summary,\\n \\\"topics\\\": topics,\\n \\\"last_updated\\\": datetime.utcnow()}\\n x = db_summaries.insert(data, check_keys=False)\\n # return json\\n summaryjson = jsonify(wisdomtopics=topics, wisdomsummary=summary)\\n return summaryjson\",\n \"def get_wotd():\\n\\treturn wotd\",\n \"def _get_wred(self):\\n return self.__wred\",\n \"def _get_wred(self):\\n return self.__wred\",\n \"def _get_wred(self):\\n return self.__wred\",\n \"def get_warc(self):\\n raise NotImplementedError()\",\n \"def svn_info_t_has_wc_info_get(svn_info_t_self): # real signature unknown; restored from __doc__\\n pass\",\n \"def wing(self):\\n return\",\n \"def is_wcw(status):\\n test_text = ' '.join(status['text'].lower().split()) # Remove capital letters and excessive whitespace/linebreaks\\n usernames = ['just_to_say_bot', 'thisisjustbot', 'Dcd200S', 'willslostplum', 'sosweetbot', 'JustToSayBot', 'thatisjustplums', \\\\\\n\\t\\t 'EatenBot', 'the_niche_bot', 'KristenCostel10', 'litabottal', 'pythonnina', 'alatest5', 'LisaRob96585017','Stilson28400122', \\\\\\n\\t\\t 'JohnDun40217560','Cordelia28', 'Rick63556459', 'botsnthings', 'timbot301', 'Rachel53001595', 'NicholasMillma6', 'ThisIsJustTo1'\\\\\\n\\t\\t'MayISay4', 'breakfast_plum', 'BotBot53368932'] # Block screen_names of known parody accounts\\n if status['user']['screen_name'] not in usernames and all(u not in status['text'] for u in usernames) and 'Cheap Bots, Done Quick!' not in status['source']:\\n if 'which you were probably' in test_text: # Capture parodies of the form\\n return True\\n elif 'plums' in test_text and 'icebox' in test_text: # Capture parodies of the content\\n return True\\n elif 'plum' in test_text and 'icebox' in test_text: # Capture singular 'plum'\\n return True\\n elif 'plums' in test_text and 'ice box' in test_text: #Capture 'ice box' with a space\\n return True\\n elif 'plum' in test_text and 'ice box' in test_text: \\n return True\\n elif 'William Carlos Williams'.lower() in test_text and 'plums' in test_text: #Capture mentions of WCW\\n return True\\n elif 'William Carlos Williams'.lower() in test_text and 'plum' in test_text:\\n return True\\n elif 'this is just to say' in test_text and 'that were in' in test_text: # Get only relevant instances of \\\"this is just to say\\\"\\n return True\\n elif 'this is just to say' in test_text and 'forgive me' in test_text:\\n return True\\n elif 'this is just to say' in test_text and 'and so' in test_text:\\n return True\\n elif 'so sweet and so cold' in test_text and 'the arms of the ocean' not in test_text: # Get 'so sweet and so cold' tweets that aren't quoting Florence and the Machine\\n return True\\n else:\\n return False\\n else:\\n return False\",\n \"def get_WS(w2v):\\n # get set of MAX_NGRAM-grams in text\\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 ngrams_in_data = set()\\n for words in raw:\\n for ngram in tweet_to_ngrams(words):\\n ngrams_in_data.add(ngram)\\n\\n # load sentiment features from model\\n clf_pipe = pickle.load(open(CLF_FNAME, 'rb')) # model\\n\\n vect = clf_pipe.best_estimator_.named_steps['vect']\\n clf = clf_pipe.best_estimator_.named_steps['clf']\\n\\n features_to_sent_idx = vect.vocabulary_ # map from model features to sentiment index\\n # currently, sentiment = 2 * (count_pos / (count_pos + count_neg)) - 1\\n sentiments = clf.feature_count_[1,:] / np.sum(clf.feature_count_, axis=0) # in [0,1]\\n sentiments = 2 * sentiments - 1 # rescale to [-1,1]\\n\\n features_to_sent = {feat: sentiments[idx] for (feat,idx) in features_to_sent_idx.items()}\\n\\n # build WS and ngram_idx_map for each MAX_NGRAM-gram in the text\\n k = len(next(iter(w2v.values()))) # dimension of embedding\\n WS = np.zeros(shape=(len(ngrams_in_data) + 1, k + MAX_NGRAM), dtype='float32')\\n ngram_idx_map = {}\\n\\n index = 1 # first row is left 0, for padding in the cnn. This is also neutral sentiment.\\n # For Vader Sentiment analysis\\n# vader_analyzer = SentimentIntensityAnalyzer()\\n\\n\\n for ngram in ngrams_in_data:\\n ngram_idx_map[ngram] = index\\n\\n # set word embedding, note that unknown words already randomized in load_embedding \\n words = ngram.split(' ')\\n WS[index,:k] = w2v[words[-1]] # embedding of last word\\n\\n # set sentiment embedding\\n for n in range(MAX_NGRAM): # for 1, 2, ... length ngrams\\n sub_ngram = ' '.join(words[-1 - n:]) \\n\\n # Naive Bayes Sentiment feature --------------------------------\\n sent = features_to_sent.get(sub_ngram, 0.0) # default to neutral 0\\n # --------------------------------------------------------------\\n\\n# # TextBlob sentiment feature -----------------------------------\\n# sent = TextBlob(sub_ngram).sentiment.polarity\\n# # --------------------------------------------------------------\\n\\n# # Vader sentiment feature -------------------------------------\\n# sent = vader_analyzer.polarity_scores(sub_ngram)['compound']\\n# # -------------------------------------------------------------\\n WS[index,k+n] = sent\\n\\n index += 1\\n\\n return WS, ngram_idx_map\",\n \"def combined_wcs(self) -> BaseHighLevelWCS:\",\n \"def get_cnt_sw_list(g_sc, g_sa, g_wn, g_wc, g_wo, g_wvi,\\r\\n pr_sc, pr_sa, pr_wn, pr_wc, pr_wo, pr_wvi,\\r\\n g_sql_i, pr_sql_i,\\r\\n mode):\\r\\n cnt_sc = get_cnt_sc_list(g_sc, pr_sc)\\r\\n cnt_sa = get_cnt_sc_list(g_sa, pr_sa)\\r\\n cnt_wn = get_cnt_sc_list(g_wn, pr_wn)\\r\\n cnt_wc = get_cnt_wc_list(g_wc, pr_wc)\\r\\n cnt_wo = get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode)\\r\\n if pr_wvi:\\r\\n cnt_wvi = get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode)\\r\\n else:\\r\\n cnt_wvi = [0]*len(cnt_sc)\\r\\n cnt_wv = get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode) # compare using wv-str which presented in original data.\\r\\n\\r\\n\\r\\n return cnt_sc, cnt_sa, cnt_wn, cnt_wc, cnt_wo, cnt_wvi, cnt_wv\",\n \"def handlehtmlsearch_wok(querystring, keywordstring, searchlimit, cache, smartconstrain):\\n mpsearch, keywords, constraints = handlehtmlsearch_mp(querystring, keywordstring, cache, smartconstrain)\\n\\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'rt') as record:\\n try:\\n wlist = json.load(record)\\n except ValueError:\\n wlist = {}\\n\\n searchtotal = 0\\n for search in mpsearch:\\n searchtotal += len(search)\\n\\n wokresults = []\\n i = 0\\n\\n for search in mpsearch:\\n for n in search:\\n iterinput = []\\n for m in n['unit_cell_formula'].keys():\\n iterinput.append(m + str(int(n['unit_cell_formula'][m])))\\n\\n iterlist = list(itertools.permutations(iterinput))\\n\\n searchparam = 'topic:' + n['pretty_formula'] + ' or topic:' + n['full_formula']\\n\\n for term in iterlist:\\n searchparam += ' or topic:' + ''.join(term)\\n\\n i += 1\\n if n['material_id'] in wlist.keys() and cache:\\n print('loading wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\\n wokresults.append(wlist[n['material_id']])\\n else:\\n print('searching wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\\n try:\\n searchdata = searchWoKTools.getsearchdata(searchparam, searchlimit)\\n except:\\n with open('wokRecord.json', 'wt') as record:\\n json.dump(wlist, record)\\n raise\\n\\n searchdata[0].update(n)\\n wlist[n['material_id']] = searchdata\\n wokresults.append(searchdata)\\n\\n mpsearch, wokresults = searchWoKTools.removeconstrainedwok(mpsearch, wokresults, constraints)\\n\\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'wt') as record:\\n json.dump(wlist, record)\\n\\n keyresults = []\\n for search in wokresults:\\n keyresults.append(searchWoKTools.getkeylist(search, keywords))\\n\\n return keywords, mpsearch, wokresults, keyresults\",\n \"def pwgrwlfilter(self):\\n return None\",\n \"def treat_page(self):\\n # let's define some basic variables\\n urtext = self.current_page.text\\n urlang = self.current_page.site.code\\n urtitle = self.current_page.title()\\n urcat = []\\n eng_site = pywikibot.Site('en')\\n eng_title = ''\\n \\n interDict = {}\\n try:\\n site = pywikibot.Site('ur', 'wikipedia')\\n urpage = pywikibot.Page(site, urtitle)\\n langlst = urpage.iterlanglinks()\\n\\n \\n for i in langlst:\\n lang = str(i.site).split(':')[1]\\n interDict[lang] = i.title\\n \\n eng_title = interDict['en']\\n except:\\n pywikibot.output(u'\\\\03{lightred}Unable to fetch interwiki links!\\\\03{default}')\\n return False\\n \\n site = pywikibot.Site('en', 'wikipedia')\\n enpage = pywikibot.Page(site, eng_title)\\n\\n wikitext = enpage.get() \\n wikicode = mwp.parse(wikitext)\\n\\n # Extracting sfn templates and converting them in REF tags\\n sfnlist = []\\n for template in wikicode.filter_templates():\\n if template.name in ('sfn', 'sfn'):\\n sfnlist.append(template)\\n templ_rep = '<ref>' + str(template) + '</ref>'\\n wikicode.replace(template , templ_rep)\\n\\n alltags = wikicode.filter_tags() \\n reftags = {}\\n \\n def search(myDict, search1):\\n for key, value in myDict.items():\\n if search1 in value: \\n return key \\n \\n i=1\\n for tag in alltags:\\n if tag.tag=='ref':\\n if tag.attributes == []: # check if attributes list is empty\\n refval='NoRefName' # Reference has no name so assigning \\\"NoRefName\\\"\\n else:\\n name = tag.attributes[0]\\n refval = name.value\\n \\n if tag.contents is None:\\n #conval = search(reftags,refval)\\n #reftags[i] = (refval,reftags[conval][1])\\n pass\\n else: \\n reftags[i] = (refval,tag.contents)\\n i += 1\\n\\n dlinks = {}\\n for k,v in reftags.items():\\n dkey = 'و' + str(k) + 'و'\\n dlinks[dkey] = '<ref>' + str(v[1]) + '</ref>'\\n\\n urtext = urpage.text\\n for r in tuple(dlinks.items()):\\n urtext = urtext.replace(*r)\\n\\n # newln = '\\\\n'\\n # Using noreferences to add Reference template if not present\\n self.norefbot = noreferences.NoReferencesBot(None)\\n if self.norefbot.lacksReferences(urtext):\\n urtext = self.norefbot.addReferences(urtext)\\n else:\\n urpage.text = urtext + '\\\\n'\\n\\n print(urpage.text)\\n \\n # save the page \\n urpage.save(summary=self.summary, minor=False)\\n #self.put_current(urpage.text, summary=self.summary)\",\n \"def CC_wdw(self):\\n # Setup param\\n loc = 'TSdata'\\n if 'single' == self.newParam['survey_type']:\\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc).shape[0]\\n elif 'multiple' == self.newParam['survey_type']:\\n TS_group = dt.utilities.DB_group_names(self.Database, group_name = loc)[0]\\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc+'/'+TS_group).shape[0]\\n\\n param = self.newParam\\n\\n # Assign TS processing length to end_wdws if given\\n if param['end_wdws']:\\n TS_sig_len = param['end_wdws']\\n else:\\n TS_sig_len = TS_len\\n\\n ERROR_MESSAGE = 'The length of a TS signal to be processed is', TS_sig_len, \\\\\\n 'which is < end of the last window'\\n\\n # Calculate wdwPos for overlapping windows of ww_ol if wdwPos is False\\n if param['wdwPos'][0] is False:\\n # Error checks\\n if TS_sig_len < self.newParam['ww'][0]:\\n raise Warning(ERROR_MESSAGE)\\n\\n wdwStep = np.floor(param['ww'][0] *\\n (100 - param['ww_ol']) / 100)\\n\\n if self.verbose: print('* Length fo TSdata', TS_len)\\n\\n max_wdwPos = TS_sig_len - param['ww'][0] + 1\\n wdwStarts = np.arange(0 + param['sta_wdws'], max_wdwPos, wdwStep).astype(int)\\n\\n if self.verbose: print('* The step in window potions is %s sample points' % wdwStep)\\n if self.verbose: print('* The max window postions is %s sample points'% max_wdwPos)\\n\\n param['wdwPos'] = [ [wdw_start, wdw_start + param['ww'][0]] for\\n wdw_start in wdwStarts ]\\n\\n # Only update wdwPos structure if not already done so\\n elif np.array(param['wdwPos'][0]).shape == ():\\n param['wdwPos'] = [ [wdw_start, wdw_start + ww] for wdw_start,ww in\\n zip(param['wdwPos'], param['ww'])]\\n\\n self.newParam['wdwPos'] = param['wdwPos']\",\n \"def fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw):\\n\\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\\n\\tTocwf=Vk*Ck*Dk/GDen\\n\\treturn Tocwf\",\n \"def buildWPriorTerm(self):\\r\\n\\r\\n # self.w_prior.shape == (minibatch size,)\\r\\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\\r\\n\\r\\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)\",\n \"def wkt(self): # -> str:\\n ...\",\n \"def _new_wos_dict():\\n wos_dict = {\\n 'DI': None,\\n 'TI': None,\\n 'PY': None,\\n 'SO': None,\\n 'UT': None,\\n 'DE': None,\\n }\\n\\n return wos_dict\",\n \"def wing_geom_eval(self, cpacs):\\n\\n log.info(\\\"---------- Analysing wing geometry ----------\\\")\\n\\n # Opening tixi and tigl\\n tixi = cpacs.tixi\\n tigl = cpacs.tigl\\n\\n # Counting wing number without symmetry --------------------------------------\\n w_nb = tixi.getNamedChildrenCount(WINGS_XPATH, \\\"wing\\\")\\n\\n # INITIALIZATION 1 -----------------------------------------------------------\\n self.w_nb = w_nb\\n self.wing_nb = w_nb\\n wing_plt_area_xz = []\\n wing_plt_area_yz = []\\n wingUID = []\\n\\n # Counting sections and segments----------------------------------------------\\n b = 0\\n for i in range(1, w_nb + 1):\\n double = 1\\n self.wing_sym.append(tigl.wingGetSymmetry(i))\\n if self.wing_sym[i - 1] != 0:\\n double = 2 # To consider the real amount of wing\\n # when they are defined using symmetry\\n self.wing_nb += 1\\n self.wing_sec_nb.append(tigl.wingGetSectionCount(i))\\n self.wing_seg_nb.append(tigl.wingGetSegmentCount(i))\\n self.wing_vol.append(tigl.wingGetVolume(i) * double)\\n\\n self.wing_plt_area.append(tigl.wingGetReferenceArea(i, 1) * double) # x-y plane\\n wing_plt_area_xz.append(tigl.wingGetReferenceArea(i, 2) * double) # x-z plane\\n wing_plt_area_yz.append(tigl.wingGetReferenceArea(i, 3) * double) # y-z plane\\n\\n self.wing_tot_vol = self.wing_tot_vol + self.wing_vol[i - 1]\\n wingUID.append(tigl.wingGetUID(i))\\n self.wing_span.append(tigl.wingGetSpan(wingUID[i - 1]))\\n a = np.amax(self.wing_span)\\n # Evaluating the index that corresponds to the main wing\\n if a > b:\\n self.main_wing_index = i\\n b = a\\n\\n # Checking segment and section connection and reordering them\\n (\\n self.wing_sec_nb,\\n _,\\n seg_sec,\\n _,\\n ) = self.wing_check_segment_connection(wing_plt_area_xz, wing_plt_area_yz, tigl)\\n\\n # INITIALIZATION 2 -----------------------------------------------------------\\n\\n max_wing_sec_nb = np.amax(self.wing_sec_nb)\\n max_wing_seg_nb = np.amax(self.wing_seg_nb)\\n wing_center_section_point = np.zeros((max_wing_sec_nb, w_nb, 3))\\n self.wing_center_seg_point = np.zeros((max_wing_seg_nb, self.wing_nb, 3))\\n self.wing_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\\n self.wing_fuel_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\\n self.wing_fuel_vol = 0\\n self.wing_mac = np.zeros((4, w_nb))\\n self.wing_sec_thickness = np.zeros((max_wing_sec_nb + 1, w_nb))\\n\\n # WING ANALYSIS --------------------------------------------------------------\\n\\n # Main wing plantform area\\n self.wing_plt_area_main = self.wing_plt_area[self.main_wing_index - 1]\\n\\n # Wing: MAC,chords,thickness,span,plantform area ------------------------------\\n\\n for i in range(1, w_nb + 1):\\n mac = tigl.wingGetMAC(wingUID[i - 1])\\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, 1, 0.0, 0.0)\\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, 1, 0.0, 1.0)\\n self.wing_max_chord.append(\\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\\n )\\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 0.0)\\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 1.0)\\n self.wing_min_chord.append(\\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\\n )\\n for k in range(1, 5):\\n self.wing_mac[k - 1][i - 1] = mac[k - 1]\\n for jj in range(1, self.wing_seg_nb[i - 1] + 1):\\n j = int(seg_sec[jj - 1, i - 1, 2])\\n cle = tigl.wingGetChordPoint(i, j, 0.0, 0.0)\\n self.wing_seg_vol[j - 1][i - 1] = tigl.wingGetSegmentVolume(i, j)\\n lp = tigl.wingGetLowerPoint(i, j, 0.0, 0.0)\\n up = tigl.wingGetUpperPoint(i, j, 0.0, 0.0)\\n if np.all(cle == lp):\\n L = 0.25\\n else:\\n L = 0.75\\n if np.all(cle == up):\\n U = 0.25\\n else:\\n U = 0.75\\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, j, 0.0, L)\\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, j, 0.0, U)\\n wing_center_section_point[j - 1][i - 1][0] = (wplx + wpux) / 2\\n wing_center_section_point[j - 1][i - 1][1] = (wply + wpuy) / 2\\n wing_center_section_point[j - 1][i - 1][2] = (wplz + wpuz) / 2\\n self.wing_sec_thickness[j - 1][i - 1] = np.sqrt(\\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\\n )\\n j = int(seg_sec[self.wing_seg_nb[i - 1] - 1, i - 1, 2])\\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, self.wing_seg_nb[i - 1], 1.0, L)\\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, self.wing_seg_nb[i - 1], 1.0, U)\\n self.wing_sec_thickness[j][i - 1] = np.sqrt(\\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\\n )\\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][0] = (wplx + wpux) / 2\\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][1] = (wply + wpuy) / 2\\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][2] = (wplz + wpuz) / 2\\n self.wing_sec_mean_thick.append(\\n np.mean(self.wing_sec_thickness[0 : self.wing_seg_nb[i - 1] + 1, i - 1])\\n )\\n # Evaluating wing fuel tank volume in the main wings\\n if abs(round(self.wing_plt_area[i - 1], 3) - self.wing_plt_area_main) < 0.001:\\n tp_ratio = self.wing_min_chord[i - 1] / self.wing_max_chord[i - 1]\\n ratio = round(tp_ratio * self.wing_plt_area[i - 1] / 100, 1)\\n if ratio >= 1.0:\\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.8, 2)\\n elif ratio >= 0.5:\\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.72, 2)\\n else:\\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.5, 2)\\n for j in seg_sec[:, i - 1, 2]:\\n if j == 0.0:\\n break\\n self.wing_fuel_seg_vol[int(j) - 1][i - 1] = round(\\n (self.wing_seg_vol[int(j) - 1][i - 1] / (sum(self.wing_vol)))\\n * self.wing_fuel_vol,\\n 2,\\n )\\n if (\\n self.wing_plt_area[i - 1] > wing_plt_area_xz[i - 1]\\n and self.wing_plt_area[i - 1] > wing_plt_area_yz[i - 1]\\n ):\\n self.is_horiz.append(True)\\n if self.wing_sym[i - 1] != 0:\\n self.is_horiz.append(True)\\n else:\\n self.is_horiz.append(False)\\n if self.wing_sym[i - 1] != 0:\\n self.is_horiz.append(False)\\n\\n # Wing segment length evaluating function\\n self.get_wing_segment_length(wing_center_section_point)\\n\\n # Evaluating the point at the center of each segment, the center\\n # is placed at 1/4 of the chord, symmetry is considered.\\n\\n a = 0\\n c = False\\n for i in range(1, int(self.wing_nb) + 1):\\n if c:\\n c = False\\n continue\\n for jj in range(1, self.wing_seg_nb[i - a - 1] + 1):\\n j = int(seg_sec[jj - 1, i - a - 1, 2])\\n self.wing_center_seg_point[j - 1][i - 1][0] = (\\n wing_center_section_point[j - 1][i - a - 1][0]\\n + wing_center_section_point[j][i - a - 1][0]\\n ) / 2\\n self.wing_center_seg_point[j - 1][i - 1][1] = (\\n wing_center_section_point[j - 1][i - a - 1][1]\\n + wing_center_section_point[j][i - a - 1][1]\\n ) / 2\\n self.wing_center_seg_point[j - 1][i - 1][2] = (\\n wing_center_section_point[j - 1][i - a - 1][2]\\n + wing_center_section_point[j][i - a - 1][2]\\n ) / 2\\n if self.wing_sym[i - 1 - a] != 0:\\n if self.wing_sym[i - 1 - a] == 1:\\n symy = 1\\n symx = 1\\n symz = -1\\n if self.wing_sym[i - 1 - a] == 2:\\n symy = -1\\n symx = 1\\n symz = 1\\n if self.wing_sym[i - 1 - a] == 3:\\n symy = 1\\n symx = -1\\n symz = 1\\n self.wing_center_seg_point[:, i, 0] = (\\n self.wing_center_seg_point[:, i - 1, 0] * symx\\n )\\n self.wing_center_seg_point[:, i, 1] = (\\n self.wing_center_seg_point[:, i - 1, 1] * symy\\n )\\n self.wing_center_seg_point[:, i, 2] = (\\n self.wing_center_seg_point[:, i - 1, 2] * symz\\n )\\n c = True\\n a += 1\\n\\n self.w_seg_sec = seg_sec\\n\\n self.wing_area = round(self.wing_plt_area_main, 3)\\n\\n log.info(\\\"---------------------------------------------\\\")\\n log.info(\\\"--------------- Wing Results ----------------\\\")\\n log.info(f\\\"Number of Wings [-]: {self.wing_nb}\\\")\\n log.info(f\\\"Wing symmetry plane [-]: {self.wing_sym}\\\")\\n log.info(f\\\"Number of wing sections (not counting symmetry) [-]: {self.wing_sec_nb}\\\")\\n log.info(f\\\"Number of wing segments (not counting symmetry) [-]: {self.wing_seg_nb}\\\")\\n log.info(f\\\"Wing Span [m]: {self.wing_span}\\\")\\n log.info(f\\\"Wing MAC length [m]: {self.wing_mac[0,]}\\\")\\n log.info(f\\\"Wing max chord length [m]: {self.wing_max_chord}\\\")\\n log.info(f\\\"Wing min chord length [m]: {self.wing_min_chord}\\\")\\n log.info(f\\\"Main wing plantform area [m^2]: {self.wing_plt_area_main}\\\")\\n log.info(f\\\"Wings plantform area [m^2]: {self.wing_plt_area}\\\")\\n log.info(f\\\"Volume of each wing [m^3]: {self.wing_vol}\\\")\\n log.info(f\\\"Total wing volume [m^3]: {self.wing_tot_vol}\\\")\\n log.info(f\\\"Wing volume for fuel storage [m^3]: {self.wing_fuel_vol}\\\")\\n log.info(\\\"---------------------------------------------\\\")\",\n \"def get_wo_mthly_smry(self, workorder_browse):\\n wo_summary_data = []\\n wo_check_dict = {}\\n no = 0\\n if workorder_browse:\\n for work_rec in workorder_browse:\\n if work_rec.state and work_rec.state == \\\"done\\\":\\n no += 1\\n identification = \\\"\\\"\\n repair_line_data = \\\"\\\"\\n if work_rec.vehicle_id:\\n identification += work_rec.vehicle_id.name\\n if work_rec.vehicle_id.f_brand_id:\\n identification += \\\" \\\" + work_rec.vehicle_id.f_brand_id.name\\n if work_rec.vehicle_id.model_id:\\n identification += \\\" \\\" + work_rec.vehicle_id.model_id.name\\n for repaire_line in work_rec.repair_line_ids:\\n if repaire_line.complete is True:\\n if (\\n repaire_line.repair_type_id\\n and repaire_line.repair_type_id.name\\n ):\\n repair_line_data += (\\n repaire_line.repair_type_id.name + \\\", \\\"\\n )\\n if work_rec.parts_ids:\\n for parts_line in work_rec.parts_ids:\\n if work_rec.id in wo_check_dict.keys():\\n parts_data = {\\n \\\"no\\\": -1,\\n \\\"location\\\": \\\"\\\",\\n \\\"type\\\": \\\"\\\",\\n \\\"wo\\\": \\\"\\\",\\n \\\"identification\\\": \\\"\\\",\\n \\\"vin\\\": \\\"\\\",\\n \\\"plate_no\\\": \\\"\\\",\\n \\\"work_performed\\\": \\\"\\\",\\n \\\"part\\\": parts_line.product_id\\n and parts_line.product_id.default_code\\n or \\\"\\\",\\n \\\"qty\\\": parts_line.qty or 0.0,\\n \\\"uom\\\": parts_line.product_uom\\n and parts_line.product_uom.name\\n or \\\"\\\",\\n }\\n wo_summary_data.append(parts_data)\\n else:\\n wo_check_dict[work_rec.id] = work_rec.id\\n parts_data = {\\n \\\"no\\\": no,\\n \\\"location\\\": work_rec.team_id\\n and work_rec.team_id.name\\n or \\\"\\\",\\n \\\"type\\\": work_rec.main_type or \\\"\\\",\\n \\\"wo\\\": work_rec.name or \\\"\\\",\\n \\\"identification\\\": identification or \\\"\\\",\\n \\\"vin\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.vin_sn\\n or \\\"\\\",\\n \\\"plate_no\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.license_plate\\n or \\\"\\\",\\n \\\"work_performed\\\": repair_line_data\\n and repair_line_data[:-2]\\n or \\\"\\\",\\n \\\"part\\\": parts_line.product_id\\n and parts_line.product_id.default_code\\n or \\\"\\\",\\n \\\"qty\\\": parts_line.qty or 0.0,\\n \\\"uom\\\": parts_line.product_uom\\n and parts_line.product_uom.name\\n or \\\"\\\",\\n }\\n wo_summary_data.append(parts_data)\\n else:\\n parts_data = {\\n \\\"no\\\": no,\\n \\\"location\\\": work_rec.team_id\\n and work_rec.team_id.name\\n or \\\"\\\",\\n \\\"type\\\": work_rec.main_type or \\\"\\\",\\n \\\"wo\\\": work_rec.name or \\\"\\\",\\n \\\"identification\\\": identification or \\\"\\\",\\n \\\"vin\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.vin_sn\\n or \\\"\\\",\\n \\\"plate_no\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.license_plate\\n or \\\"\\\",\\n \\\"work_performed\\\": repair_line_data\\n and repair_line_data[:-2]\\n or \\\"\\\",\\n \\\"vehicle_make\\\": \\\"\\\",\\n \\\"qty\\\": \\\"\\\",\\n \\\"uom\\\": \\\"\\\",\\n }\\n wo_summary_data.append(parts_data)\\n if not wo_summary_data:\\n msg = _(\\n \\\"Warning! \\\\n\\\\\\n No data Available for selected work order.\\\"\\n )\\n raise UserError(msg)\\n return wo_summary_data\",\n \"def analyzeWeights(self, occludedPortions):\\r\\n\\t\\treturn None\",\n \"def update(self):\\n self.wc.update()\",\n \"def original_wcs(self):\\n return self._owcs\",\n \"def lookup(doc, wv):\\n checked = []\\n for word in doc:\\n try:\\n word in wv\\n except KeyError:\\n log.warning(\\\"Word not in model: %s\\\", word)\\n continue\\n checked.append(wv[word])\\n vec = np.mean(checked, axis=0)\\n return vec\",\n \"def give_wv_units(wave):\\n if not hasattr(wave, 'unit'):\\n uwave = u.Quantity(wave, unit=u.AA)\\n elif wave.unit is None:\\n uwave = u.Quantity(wave, unit=u.AA)\\n else:\\n uwave = u.Quantity(wave)\\n\\n return uwave\",\n \"def wrez2xml(self,newdoc,newroot):\\n\\t\\twrez = newdoc.createElement('wrez')\\n\\t\\twrez.setAttribute('hasChanged', str(self.hasChanged))\\n\\t\\tnewroot.appendChild(wrez)\\n\\n\\t\\tpath = newdoc.createElement('path')\\n\\t\\tpath.setAttribute('value', self.path)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('init_str')\\n\\t\\tpath.setAttribute('value', self.init_str)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('hash_sha512')\\n\\t\\tpath.setAttribute('value', self.hash_sha512)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('src_rip')\\n\\t\\tpath.setAttribute('value', self.src_rip)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('quality')\\n\\t\\tpath.setAttribute('value', self.quality)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('codec')\\n\\t\\tpath.setAttribute('value', self.codec)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('language')\\n\\t\\tpath.setAttribute('value', self.language)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('audio')\\n\\t\\tpath.setAttribute('value', self.audio)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('encoder')\\n\\t\\tpath.setAttribute('value', self.encoder)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('version')\\n\\t\\tpath.setAttribute('value', self.version)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('extension')\\n\\t\\tpath.setAttribute('value', self.extension)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('release_year')\\n\\t\\tpath.setAttribute('value', self.release_year)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('title')\\n\\t\\tpath.setAttribute('value', self.title)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('size')\\n\\t\\tpath.setAttribute('value', str(self.size))\\n\\t\\twrez.appendChild(path)\\n\\t\\treturn wrez\",\n \"def get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode):\\r\\n cnt_list=[]\\r\\n for b, g_wo1 in enumerate(g_wo):\\r\\n g_wc1 = g_wc[b]\\r\\n pr_wc1 = pr_wc[b]\\r\\n pr_wo1 = pr_wo[b]\\r\\n pr_wn1 = len(pr_wo1)\\r\\n g_wn1 = g_wn[b]\\r\\n\\r\\n if g_wn1 != pr_wn1:\\r\\n cnt_list.append(0)\\r\\n continue\\r\\n else:\\r\\n # Sort based wc sequence.\\r\\n if mode == 'test':\\r\\n idx = argsort(array(g_wc1))\\r\\n\\r\\n g_wo1_s = array(g_wo1)[idx]\\r\\n g_wo1_s = list(g_wo1_s)\\r\\n elif mode == 'train':\\r\\n # due to tearch forcing, no need to sort.\\r\\n g_wo1_s = g_wo1\\r\\n else:\\r\\n raise ValueError\\r\\n\\r\\n if type(pr_wo1) != list:\\r\\n raise TypeError\\r\\n if g_wo1_s == pr_wo1:\\r\\n cnt_list.append(1)\\r\\n else:\\r\\n cnt_list.append(0)\\r\\n return cnt_list\",\n \"def onReload(self, event):\\n\\n\\t\\tself.wv.Reload()\",\n \"def test_mlpi_cwro(self):\\r\\n\\t\\twith open(\\\"test_mlpi_cwro.txt\\\", \\\"w\\\") as test_mlpi_cwro_output:\\r\\n\\t\\t\\tsys.stdout = test_mlpi_cwro_output\\r\\n\\t\\t\\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=100, censor_words_one_pass=True)\\r\\n\\t\\twith open(\\\"test_mlpi_cwro.txt\\\", \\\"r\\\") as test_mlpi_cwro_output:\\r\\n\\t\\t\\twhile True:\\r\\n\\t\\t\\t\\tline_output = test_mlpi_cwro_output.readline()\\r\\n\\t\\t\\t\\tline_correct = cc_test_prose.readline()\\r\\n\\t\\t\\t\\tself.assertEqual(line_output, line_correct)\\r\\n\\t\\t\\t\\tif line_correct == '':\\r\\n\\t\\t\\t\\t\\tbreak\\r\\n\\t\\tcc_test_prose.seek(0)\\r\\n\\t\\tsys.stdout = sys.__stdout__\\r\\n\\t\\tos.remove(\\\"test_mlpi_cwro.txt\\\")\",\n \"def primalrepair(self,wlc,wuc,wlx,wux): # 3\\n if wlc is None:\\n wlc_ = None\\n else:\\n try:\\n wlc_ = memoryview(wlc)\\n except TypeError:\\n try:\\n _tmparr_wlc = array.array(\\\"d\\\",wlc)\\n except TypeError:\\n raise TypeError(\\\"Argument wlc has wrong type\\\")\\n else:\\n wlc_ = memoryview(_tmparr_wlc)\\n \\n else:\\n if wlc_.format != \\\"d\\\":\\n wlc_ = memoryview(array.array(\\\"d\\\",wlc))\\n \\n if wlc_ is not None and len(wlc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wlc has wrong length\\\")\\n if wuc is None:\\n wuc_ = None\\n else:\\n try:\\n wuc_ = memoryview(wuc)\\n except TypeError:\\n try:\\n _tmparr_wuc = array.array(\\\"d\\\",wuc)\\n except TypeError:\\n raise TypeError(\\\"Argument wuc has wrong type\\\")\\n else:\\n wuc_ = memoryview(_tmparr_wuc)\\n \\n else:\\n if wuc_.format != \\\"d\\\":\\n wuc_ = memoryview(array.array(\\\"d\\\",wuc))\\n \\n if wuc_ is not None and len(wuc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wuc has wrong length\\\")\\n if wlx is None:\\n wlx_ = None\\n else:\\n try:\\n wlx_ = memoryview(wlx)\\n except TypeError:\\n try:\\n _tmparr_wlx = array.array(\\\"d\\\",wlx)\\n except TypeError:\\n raise TypeError(\\\"Argument wlx has wrong type\\\")\\n else:\\n wlx_ = memoryview(_tmparr_wlx)\\n \\n else:\\n if wlx_.format != \\\"d\\\":\\n wlx_ = memoryview(array.array(\\\"d\\\",wlx))\\n \\n if wlx_ is not None and len(wlx_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wlx has wrong length\\\")\\n if wux is None:\\n wux_ = None\\n else:\\n try:\\n wux_ = memoryview(wux)\\n except TypeError:\\n try:\\n _tmparr_wux = array.array(\\\"d\\\",wux)\\n except TypeError:\\n raise TypeError(\\\"Argument wux has wrong type\\\")\\n else:\\n wux_ = memoryview(_tmparr_wux)\\n \\n else:\\n if wux_.format != \\\"d\\\":\\n wux_ = memoryview(array.array(\\\"d\\\",wux))\\n \\n if wux_ is not None and len(wux_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wux has wrong length\\\")\\n res = self.__obj.primalrepair(wlc_,wuc_,wlx_,wux_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def primalrepair(self,wlc_,wuc_,wlx_,wux_):\\n _wlc_minlength = self.getnumcon()\\n if self.getnumcon() > 0 and wlc_ is not None and len(wlc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wlc is not long enough: Is %d, expected %d\\\" % (len(wlc_),self.getnumcon()))\\n if isinstance(wlc_, numpy.ndarray) and wlc_.dtype is numpy.dtype(numpy.float64) and wlc_.flags.contiguous:\\n _wlc_copyarray = False\\n _wlc_tmp = ctypes.cast(wlc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wlc_ is not None:\\n _wlc_copyarray = True\\n _wlc_np_tmp = numpy.zeros(len(wlc_),numpy.dtype(numpy.float64))\\n _wlc_np_tmp[:] = wlc_\\n assert _wlc_np_tmp.flags.contiguous\\n _wlc_tmp = ctypes.cast(_wlc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wlc_copyarray = False\\n _wlc_tmp = None\\n \\n _wuc_minlength = self.getnumcon()\\n if self.getnumcon() > 0 and wuc_ is not None and len(wuc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wuc is not long enough: Is %d, expected %d\\\" % (len(wuc_),self.getnumcon()))\\n if isinstance(wuc_, numpy.ndarray) and wuc_.dtype is numpy.dtype(numpy.float64) and wuc_.flags.contiguous:\\n _wuc_copyarray = False\\n _wuc_tmp = ctypes.cast(wuc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wuc_ is not None:\\n _wuc_copyarray = True\\n _wuc_np_tmp = numpy.zeros(len(wuc_),numpy.dtype(numpy.float64))\\n _wuc_np_tmp[:] = wuc_\\n assert _wuc_np_tmp.flags.contiguous\\n _wuc_tmp = ctypes.cast(_wuc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wuc_copyarray = False\\n _wuc_tmp = None\\n \\n _wlx_minlength = self.getnumvar()\\n if self.getnumvar() > 0 and wlx_ is not None and len(wlx_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wlx is not long enough: Is %d, expected %d\\\" % (len(wlx_),self.getnumvar()))\\n if isinstance(wlx_, numpy.ndarray) and wlx_.dtype is numpy.dtype(numpy.float64) and wlx_.flags.contiguous:\\n _wlx_copyarray = False\\n _wlx_tmp = ctypes.cast(wlx_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wlx_ is not None:\\n _wlx_copyarray = True\\n _wlx_np_tmp = numpy.zeros(len(wlx_),numpy.dtype(numpy.float64))\\n _wlx_np_tmp[:] = wlx_\\n assert _wlx_np_tmp.flags.contiguous\\n _wlx_tmp = ctypes.cast(_wlx_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wlx_copyarray = False\\n _wlx_tmp = None\\n \\n _wux_minlength = self.getnumvar()\\n if self.getnumvar() > 0 and wux_ is not None and len(wux_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wux is not long enough: Is %d, expected %d\\\" % (len(wux_),self.getnumvar()))\\n if isinstance(wux_, numpy.ndarray) and wux_.dtype is numpy.dtype(numpy.float64) and wux_.flags.contiguous:\\n _wux_copyarray = False\\n _wux_tmp = ctypes.cast(wux_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wux_ is not None:\\n _wux_copyarray = True\\n _wux_np_tmp = numpy.zeros(len(wux_),numpy.dtype(numpy.float64))\\n _wux_np_tmp[:] = wux_\\n assert _wux_np_tmp.flags.contiguous\\n _wux_tmp = ctypes.cast(_wux_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wux_copyarray = False\\n _wux_tmp = None\\n \\n res = __library__.MSK_XX_primalrepair(self.__nativep,_wlc_tmp,_wuc_tmp,_wlx_tmp,_wux_tmp)\\n if res != 0:\\n _,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def vp():\\r\\n section = document.add_section()\\r\\n new_width, new_height = section.page_height, section.page_width\\r\\n section.orientation = WD_ORIENT.LANDSCAPE\\r\\n section.page_width = 10058400\\r\\n section.page_height = 7772400\\r\\n document.add_heading('Virtual Proxy details', 1)\\r\\n virtualproxy_metrics= ['description', 'prefix', 'authenticationModuleRedirectUri', 'sessionModuleBaseUri', 'loadBalancingModuleBaseUri', 'authenticationMethod', 'headerAuthenticationMode',\\r\\n 'headerAuthenticationHeaderName', 'headerAuthenticationStaticUserDirectory', 'headerAuthenticationDynamicUserDirectory', 'anonymousAccessMode', 'windowsAuthenticationEnabledDevicePattern',\\r\\n 'sessionCookieHeaderName', 'sessionCookieDomain', 'additionalResponseHeaders', 'sessionInactivityTimeout', 'extendedSecurityEnvironment', 'websocketCrossOriginWhiteList', 'defaultVirtualProxy',\\r\\n 'tags','samlMetadataIdP', 'samlHostUri', 'samlEntityId', 'samlAttributeUserId', 'samlAttributeUserDirectory', 'samlAttributeSigningAlgorithm', 'samlAttributeMap', 'magicLinkHostUri',\\r\\n 'magicLinkFriendlyName','jwtPublicKeyCertificate','jwtAttributeUserDirectory','jwtAttributeMap','jwtAttributeUserId']\\r\\n \\r\\n virtualproxynodes = get_qlik_sense.get_virtualproxy()\\r\\n num_of_virtualproxys = len(virtualproxynodes)\\r\\n num_of_virtualproxy_metrics = len(virtualproxy_metrics)\\r\\n table = document.add_table(rows=num_of_virtualproxy_metrics+1, cols=num_of_virtualproxys+1)\\r\\n table.style = 'Grid Table 1 Light Accent 1'\\r\\n row = table.rows[0]\\r\\n row.cells[0].text = 'Metric'\\r\\n for item in range(0, num_of_virtualproxys):\\r\\n row.cells[item+1].text = virtualproxynodes[item][29]\\r\\n for item in range(num_of_virtualproxy_metrics):\\r\\n row = table.rows[item+1]\\r\\n row.cells[0].text = str(virtualproxy_metrics[item])\\r\\n for virtualproxynode in range(num_of_virtualproxys):\\r\\n row.cells[virtualproxynode+1].text = str(virtualproxynodes[virtualproxynode][item])\\r\\n\\r\\n document.add_page_break()\",\n \"def get_bforce_wm_ws_Gx_surf(self):\\n\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w'] \\n \\n self.Gm1 = np.zeros([Ly])\\n self.dGm1_dS = np.zeros([Ly]) \\n self.Gt1 = np.zeros([Ly])\\n self.dGt1_dS = np.zeros([Ly]) \\n self.Bfsfc_bl = np.zeros([Ly])\\n self.Av_bl = np.zeros([Ly])\\n self.dAv_bl = np.zeros([Ly])\\n \\n #debugging\\n self.wm_surf = np.zeros([Ly])\\n self.ws_surf = np.zeros([Ly]) \\n\\n #---> j-loop\\n for j in range(Ly): \\n k_w = self.kbl[j] # KBL is \\\"new bl index after calling find_new_kbl()\\n z_bl = z_u_w[j,N] - self.hbls[j]\\n zscale = self.hbls[j] \\n \\n if self.swr_frac[j,k_w-1] > 0:\\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\\n \\n else:\\n Bfsfc = self.Bo[j] + self.Bosol[j]\\n \\n # CALCUALTE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm_surf[j] = wm\\n self.ws_surf[j] = ws \\n\\n if self.LIMIT_UNSTABLE_ONLY:\\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\\n else:\\n f1 = 0\\n\\n \\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n\\n #MOMENTUM \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl[j] = Av_bl\\n self.dAv_bl[j] = dAv_bl\\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \\n\\n #TEMPERATURE(BUOYANCY)\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \\n\\n self.Bfsfc_bl[j] = Bfsfc\",\n \"def get_w(self):\\n raise NotImplementedError\",\n \"def propose(self):\\n\\n\\n fb = 0.0\\n changed_any = False\\n\\n while not changed_any:\\n new = copy(self) ## Now we just copy the whole thing\\n\\n for w in self.all_words():\\n if flip(self.propose_p):\\n try:\\n xp, xfb = self.get_word(w).propose()\\n\\n changed_any = True\\n new.set_word(w, xp)\\n fb += xfb\\n\\n except ProposalFailedException:\\n pass\\n\\n\\n return new, fb\",\n \"def build_W(points):\\n return None\",\n \"def computeW(self):\\n E = np.where(self.v > 0, 1, -1)\\n # theshold the connections to only -1,1\\n binary_weights = np.where(self.c > 0, 1, self.c)\\n binary_weights = np.where(binary_weights < 0, -1, binary_weights)\\n W = np.sum(binary_weights * np.dot(E.reshape(-1,1), E.reshape(1,-1))) # W = C * E * E\\n self.W = W\\n if np.sum(binary_weights) != 0:\\n self.W = self.W / np.sum(binary_weights) # W / W*\\n return self.W\",\n \"def vcac_worklfow_request(self):\\n logging.info(\\\"Inside ucsvm_worklfow_request method base class\\\")\\n return None\",\n \"def get_wordcloud():\\n params = request.args\\n result = None\\n\\n def set_result(x):\\n nonlocal result # This is ugly, ew, gotta fix this\\n result = x\\n\\n pipeline_zoo.get_full_word_distribution(set_result).feed_data((params, None))\\n return jsonify({\\n 'word_distribution': result\\n })\",\n \"def get_vector(word, model):\\n return model.wv[word]\",\n \"def new_words_only(base_words, window_words):\\n new_words = []\\n if base_words:\\n for wword in window_words:\\n dont_include = False\\n for bword in base_words:\\n if CharNetRunner._do_words_intersect(wword, bword):\\n dont_include = True\\n break\\n if not dont_include:\\n new_words.append(wword)\\n else:\\n new_words = window_words\\n\\n return new_words\",\n \"def build_parameters(pobj):\\n ViscosityWilke.build_parameters(pobj)\",\n \"def search_clues(self):\\r\\n print(\\\"\\\\n************Searching Clues************\\\\n\\\")\\r\\n for word_id in self.words.keys():\\r\\n if not self.words[word_id].see and not self.words[word_id].wth:\\r\\n clue = pop_backslash(self.words[word_id].clue)\\r\\n temp = word_domain(\\\"allintext:\\\" + clue +' -crossword',self.words[word_id].length)\\r\\n temp2 = temp + word_domain(clue +' -crossword',self.words[word_id].length)\\r\\n domain = temp2 + data_muse(clue, self.words[word_id].length)\\r\\n unique_list = []\\r\\n for x in domain: \\r\\n y = x.upper()\\r\\n # check if exists in unique_list or not \\r\\n if y not in unique_list: \\r\\n unique_list.append(y) \\r\\n \\r\\n self.words[word_id].assign_word_domain(unique_list)\\r\\n print(\\\"\\\\nSearch is done...\\\")\",\n \"def wps(model, data):\\n with msg.loading(f\\\"Loading model '{model}'...\\\"):\\n nlp = spacy.load(model)\\n texts = (eg[\\\"text\\\"] for eg in srsly.read_jsonl(data))\\n n_docs = 0\\n n_words = 0\\n start_time = timer()\\n for doc in nlp.pipe(texts):\\n n_docs += 1\\n n_words += len(doc)\\n end_time = timer()\\n wps = int(n_words / (end_time - start_time))\\n result = [\\n (\\\"Docs\\\", f\\\"{n_docs:,}\\\"),\\n (\\\"Words\\\", f\\\"{n_words:,}\\\"),\\n (\\\"Words/s\\\", f\\\"{wps:,}\\\"),\\n ]\\n msg.table(result, widths=(7, 12), aligns=(\\\"l\\\", \\\"r\\\"))\",\n \"def isMWS_WD(primary=None, gaia=None, galb=None, astrometricexcessnoise=None,\\n pmra=None, pmdec=None, parallax=None, parallaxovererror=None,\\n photbprpexcessfactor=None, astrometricsigma5dmax=None,\\n gaiagmag=None, gaiabmag=None, gaiarmag=None, paramssolved=None):\\n if primary is None:\\n primary = np.ones_like(gaia, dtype='?')\\n mws = primary.copy()\\n\\n # ADM do not target any objects for which entries are NaN\\n # ADM and turn off the NaNs for those entries.\\n if photbprpexcessfactor is not None:\\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\\n np.isnan(parallax) | np.isnan(photbprpexcessfactor))\\n else:\\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\\n np.isnan(parallax))\\n w = np.where(nans)[0]\\n if len(w) > 0:\\n parallax, gaiagmag = parallax.copy(), gaiagmag.copy()\\n gaiabmag, gaiarmag = gaiabmag.copy(), gaiarmag.copy()\\n if photbprpexcessfactor is not None:\\n photbprpexcessfactor = photbprpexcessfactor.copy()\\n # ADM safe to make these zero regardless of cuts as...\\n photbprpexcessfactor[w] = 0.\\n parallax[w] = 0.\\n gaiagmag[w], gaiabmag[w], gaiarmag[w] = 0., 0., 0.\\n # ADM ...we'll turn off all bits here.\\n mws &= ~nans\\n# log.info('{}/{} NaNs in file...t = {:.1f}s'\\n# .format(len(w), len(mws), time()-start))\\n\\n # ADM apply the selection for all MWS-WD targets\\n # ADM must be a Legacy Surveys object that matches a Gaia source\\n mws &= gaia\\n\\n # ADM and all astrometric parameters are measured.\\n mws &= paramssolved == 31\\n\\n # ADM Gaia G mag of less than 20\\n mws &= gaiagmag < 20.\\n\\n # ADM Galactic b at least 20o from the plane\\n mws &= np.abs(galb) > 20.\\n\\n # ADM gentle cut on parallax significance\\n mws &= parallaxovererror > 1.\\n\\n # ADM Color/absolute magnitude cuts of (defining the WD cooling sequence):\\n # ADM Gabs > 5\\n # ADM Gabs > 5.93 + 5.047(Bp-Rp)\\n # ADM Gabs > 6(Bp-Rp)3 - 21.77(Bp-Rp)2 + 27.91(Bp-Rp) + 0.897\\n # ADM Bp-Rp < 1.7\\n Gabs = gaiagmag+5.*np.log10(parallax.clip(1e-16))-10.\\n br = gaiabmag - gaiarmag\\n mws &= Gabs > 5.\\n mws &= Gabs > 5.93 + 5.047*br\\n mws &= Gabs > 6*br*br*br - 21.77*br*br + 27.91*br + 0.897\\n mws &= br < 1.7\\n\\n # ADM Finite proper motion to reject quasars\\n # ADM Inexplicably I'm getting a Runtimewarning here for\\n # ADM a few values in the sqrt, so I'm catching it\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n pm = np.sqrt(pmra**2. + pmdec**2.)\\n mws &= pm > 2.\\n\\n # ADM As of DR7, photbprpexcessfactor and astrometricsigma5dmax are not in the\\n # ADM imaging catalogs. Until they are, ignore these cuts\\n if photbprpexcessfactor is not None:\\n # ADM remove problem objects, which often have bad astrometry\\n mws &= photbprpexcessfactor < 1.7 + 0.06*br*br\\n\\n if astrometricsigma5dmax is not None:\\n # ADM Reject white dwarfs that have really poor astrometry while\\n # ADM retaining white dwarfs that only have relatively poor astrometry\\n mws &= ((astrometricsigma5dmax < 1.5) |\\n ((astrometricexcessnoise < 1.) & (parallaxovererror > 4.) & (pm > 10.)))\\n\\n return mws\",\n \"def get_doc_prov(j, gcis_url, refList):\\n gcis_ns = \\\"https://gcis-search-stage.jpl.net:3000/gcis.owl#\\\"\\n doc = ProvEsDocument()\\n bndl = None\\n \\n#to get people attributed to, you need to grab article -> jornal_identifier -> look up in references\\n# for ref in refList:\\n# if ref['child_publication'] == j['uri']:\\n \\n\\n\\n doc_attrs = [\\n (\\\"prov:type\\\", 'gcis:Article'),\\n (\\\"prov:label\\\", j['title']),\\n (\\\"prov:location\\\", j['uri']),\\n #(\\\"prov:wasAttributedTo\\\", j['']),\\n ]\\n doc.entity('bibo:%s' % j['identifier'], doc_attrs)\\n\\n prov_json = json.loads(doc.serialize())\\n\\n return prov_json\",\n \"def test_visualize_wfe_budget():\\n nrc = webbpsf.NIRCam()\\n nrc.visualize_wfe_budget()\",\n \"def evaluate_design(self): # to update the pr object\",\n \"def getVWFile(tsvFile, vwFile, dataIndex, dictionary, tfidf_model, train=True):\\r\\n start = datetime.now()\\r\\n \\r\\n # extract all the index\\r\\n catIndex = dataIndex[\\\"catIndex\\\"]\\r\\n subCatIndex = dataIndex[\\\"subCatIndex\\\"]\\r\\n attrsKeyIndex = dataIndex[\\\"attrsKeyIndex\\\"]\\r\\n attrsValIndex = dataIndex[\\\"attrsValIndex\\\"]\\r\\n wordIndex = dataIndex[\\\"wordIndex\\\"]\\r\\n \\r\\n with open(vwFile, \\\"wb\\\") as vwWriter:\\r\\n with open(tsvFile, \\\"rb\\\") as tsvReader:\\r\\n itemReader = DictReader(tsvReader, delimiter='\\\\t', quotechar='\\\"')\\r\\n for i, item in enumerate(itemReader):\\r\\n item = {featureName:featureValue.decode('utf-8') \\\\\\r\\n for featureName,featureValue in item.items() \\\\\\r\\n if featureValue is not None}\\r\\n\\r\\n # get header\\r\\n itemid = int(item[\\\"itemid\\\"])\\r\\n label = int(item[\\\"is_blocked\\\"]) if train else 1\\r\\n header = \\\"%s '%s \\\" % (int(2*label - 1), itemid)\\r\\n \\r\\n # category\\r\\n categoryFeat = \\\"|C %s \\\" % catIndex[ item[\\\"category\\\"] ]\\r\\n \\r\\n # subcategory\\r\\n subcategoryFeat = \\\"|SC %s \\\" % subCatIndex[ item[\\\"subcategory\\\"] ]\\r\\n \\r\\n # title\\r\\n title = [ str(wordIndex[w]) for w in getWords(item[\\\"title\\\"]) ]\\r\\n # first-gram\\r\\n title_start = title[0] if len(title)>0 else \\\"0\\\"\\r\\n # end-gram\\r\\n title_end = title[-1] if len(title)>0 else \\\"0\\\"\\r\\n # naming is a pain for me\\r\\n titleFeat = \\\"|T %s |bT %s |cT %s \\\" % (\\\" \\\".join(title), title_start, title_end)\\r\\n titleStatsFeat = \\\"|t %s \\\" % getTextStatsFeat(item[\\\"title\\\"])\\r\\n \\r\\n # description\\r\\n description = [ str(wordIndex[w]) for w in getWords(item[\\\"description\\\"]) ]\\r\\n # first-gram\\r\\n description_start = description[0] if len(description)>0 else \\\"0\\\"\\r\\n # end-gram\\r\\n description_end = description[-1] if len(description)>0 else \\\"0\\\"\\r\\n descriptionFeat = \\\"|D %s |fD %s |gD %s \\\" % (\\\" \\\".join(description), description_start, description_end)\\r\\n descriptionStatsFeat = \\\"|d %s \\\" % getTextStatsFeat(item[\\\"description\\\"])\\r\\n tfidf_feat1 = getTfidfFeat(getUnigram(description), dictionary[1], tfidf_model[1])\\r\\n # 2gram tfidf seem to harm the performance, you are save to drop it here\\r\\n tfidf_feat2 = getTfidfFeat(getBigram(description, \\\"_\\\"), dictionary[2], tfidf_model[2])\\r\\n descriptionFeat += \\\"|iD %s |jD %s \\\" % (tfidf_feat1, tfidf_feat2)\\r\\n \\r\\n # attrs\\r\\n attrsFeat = \\\"\\\"\\r\\n countAttrs = 0\\r\\n if \\\"attrs\\\" in item:\\r\\n attrsDict = getAttrsDict(item[\\\"attrs\\\"])\\r\\n #print attrs\\r\\n for k,v in list(attrsDict.items()):\\r\\n countAttrs += 1\\r\\n attrsFeat += \\\"|A%s %s \\\" % (attrsKeyIndex[k], attrsValIndex[v])\\r\\n attrsFeat += \\\"|a \\\"\\r\\n for k,v in list(attrsDict.items()):\\r\\n attrsFeat += \\\"%s \\\" % (attrsKeyIndex[k]) \\r\\n if len(attrsFeat) == 0:\\r\\n attrsFeat = \\\"|NA 1 \\\"\\r\\n attrsFeat += \\\"|hAC %s \\\" % countAttrs\\r\\n \\r\\n # price\\r\\n priceFeat = \\\"|P %s \\\" % item[\\\"price\\\"] \\r\\n # phones_cnt\\r\\n phonesCntFeat = \\\"|p %s \\\" % item[\\\"phones_cnt\\\"]\\r\\n # emails_cnt\\r\\n emailsCntFeat = \\\"|e %s \\\" % item[\\\"emails_cnt\\\"]\\r\\n # urls_cnt\\r\\n urlsCntFeat = \\\"|u %s \\\" % item[\\\"urls_cnt\\\"]\\r\\n \\r\\n # output\\r\\n vwLine = header \\\\\\r\\n + categoryFeat \\\\\\r\\n + subcategoryFeat \\\\\\r\\n + titleFeat \\\\\\r\\n + titleStatsFeat \\\\\\r\\n + descriptionFeat \\\\\\r\\n + descriptionStatsFeat \\\\\\r\\n + attrsFeat \\\\\\r\\n + priceFeat \\\\\\r\\n + phonesCntFeat \\\\\\r\\n + emailsCntFeat \\\\\\r\\n + urlsCntFeat[:-1] + \\\"\\\\n\\\"\\r\\n vwWriter.write( vwLine )\\r\\n \\r\\n # report progress\\r\\n if (i+1)%10000 == 0:\\r\\n print(( \\\"\\\\n%s\\\\t%s\\\"%((i+1),str(datetime.now() - start)) ))\\r\\n print(( \\\"Sample output:\\\\n%s\\\" % vwLine ))\",\n \"def check_wf(self,wf):\\n pass\",\n \"def geocube():\",\n \"def has_wcs(self):\\n return self.wcs is not None\",\n \"def plotrgcloud(self):\\n print self.kpunten\\n for i in range(len(self.kpunten[0])):\\n self.writetext('sen ='+ self.kpunten[0][i][0], (0.65,0.85), axnum = 0, hor = None ,ver = None , rot = None ,fs =14 , transform = self.fig.axes[0].transAxes)\\n if i == len(self.kpunten[0]) -1 :\\n end = None\\n else:\\n end = self.kpunten[0][i+1][1] + 1\\n print end\\n self.plotrgwrap( self.rgindex,2*self.reader.npair+self.rgindex,'real part of rgvars (a.u)' , 'imaginary part of rgvars (a.u.)', tit ='RG vars g = %f all states'%(self.chardata) , begin = self.kpunten[0][i][1] , stop = end , name = 'cpcloud'+ self.kpunten[0][i][0] , filenum = 0)\",\n \"def newWS(self, y):\\n keys=np.array(self.ImageSolution.keys())\\n try:\\n i=abs(keys-y).argmin()\\n ws=self.ImageSolution[keys[i]]\\n nws=WavelengthSolution.WavelengthSolution(ws.x_arr,ws.w_arr, order=ws.order, function=ws.function)\\n nws.fit()\\n return nws\\n except :\\n return self.ws\",\n \"def calc_wvf(pedestrian, key, face, mesh_area,radius): \\n normal = envuo.py3dmodel.construct.make_vector((0,0,0),envuo.py3dmodel.calculate.face_normal(face))\\n surf2ped = envuo.py3dmodel.construct.make_vector(key,pedestrian)\\n sa_ped = 4.0*np.pi*radius**2\\n theta = normal.Angle(surf2ped)\\n h = surf2ped.Magnitude()/radius \\n phi = np.arctan(1/h)\\n threshold = np.pi/2.0 - phi\\n\\n if abs(h*np.cos(theta)) > 1:\\n F = abs(np.cos(theta))/h**2; \\n else:\\n x = np.sqrt(h**2-1)/np.tan(theta) #np.sqrt(h**2-1)\\n y = np.sqrt(1-x**2) #-x/np.tan(theta) #\\n F = (np.pi - abs(np.cos(x)) - x*y*np.tan(theta)**2)*abs(np.cos(theta))/(np.pi*h**2) + np.arctan(y*abs(np.cos(theta))/x)/np.pi; \\n print pedestrian,' passes threshold'\\n return mesh_area*F/sa_ped\",\n \"def compute_RS(W):\\n return None\",\n \"def _vSWVT(self):\\r\\n\\r\\n logStr = \\\"{0:s}.{1:s}: \\\".format(self.__class__.__name__, sys._getframe().f_code.co_name)\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'Start.')) \\r\\n \\r\\n try: \\r\\n vSWVT = None\\r\\n vSWVT=pd.merge(self.dataFrames['SWVT'],self.dataFrames['SWVT_ROWT'],left_on='pk',right_on='fk')\\r\\n vSWVT['ZEIT']=pd.to_numeric(vSWVT['ZEIT']) \\r\\n vSWVT['W']=pd.to_numeric(vSWVT['W']) \\r\\n vSWVT['ZEIT_RANG']=vSWVT.groupby(['pk_x'])['ZEIT'].rank(ascending=True)\\r\\n #\\r\\n vSWVT_g=vSWVT.groupby(['pk_x'], as_index=False).agg({'W':[np.min,np.max]})\\r\\n vSWVT_g.columns= [tup[0]+tup[1] for tup in zip(vSWVT_g.columns.get_level_values(0),vSWVT_g.columns.get_level_values(1))]\\r\\n vSWVT_g.rename(columns={'Wamin':'W_min','Wamax':'W_max'},inplace=True)\\r\\n #\\r\\n vSWVT=pd.merge(vSWVT,vSWVT_g,left_on='pk_x',right_on='pk_x')\\r\\n #\\r\\n vSWVT=vSWVT[vSWVT['ZEIT_RANG']==1]\\r\\n #\\r\\n vSWVT=vSWVT[['NAME','BESCHREIBUNG','INTPOL','ZEITOPTION','W','W_min','W_max','pk_x']]\\r\\n #\\r\\n vSWVT.rename(columns={'pk_x':'pk'},inplace=True)\\r\\n \\r\\n except Exception as e:\\r\\n logStrFinal=\\\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\\\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\\r\\n logger.error(logStrFinal) \\r\\n raise XmError(logStrFinal) \\r\\n finally:\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'_Done.'))\\r\\n return vSWVT\",\n \"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',\\n verbose=False))\\n # No NaNs are supposed to be in the output.\\n self.assertEqual(np.isnan(wv).any(), False)\\n rms1 = rms(rec['wv_250_500_25'], wv[250:500:25])\\n rms2 = rms(rec['wv_750_1000_25'], wv[750:1000:25])\\n self.assertEqual(True, rms1 < 1e-6)\\n self.assertEqual(True, rms2 < 1e-6)\",\n \"def test_slpi_cwro(self):\\r\\n\\t\\twith open(\\\"test_slpi_cwro.txt\\\", \\\"w\\\") as test_slpi_cwro_output:\\r\\n\\t\\t\\tsys.stdout = test_slpi_cwro_output # Redirect print in censor to temporary output file\\r\\n\\t\\t\\t# Appropriate censor function call\\r\\n\\t\\t\\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=1, censor_words_one_pass=True)\\r\\n\\t\\twith open(\\\"test_slpi_cwro.txt\\\", \\\"r\\\") as test_slpi_cwro_output:\\r\\n\\t\\t\\twhile True:\\r\\n\\t\\t\\t\\t# Assert every output line in file matches the expected output\\r\\n\\t\\t\\t\\tline_output = test_slpi_cwro_output.readline()\\r\\n\\t\\t\\t\\tline_correct = cc_test_prose.readline()\\r\\n\\t\\t\\t\\tself.assertEqual(line_output, line_correct)\\r\\n\\t\\t\\t\\tif line_correct == '': # Stop reading expected output at eof\\r\\n\\t\\t\\t\\t\\tbreak\\r\\n\\t\\tcc_test_prose.seek(0) # Reset read head in expected output file\\r\\n\\t\\tsys.stdout = sys.__stdout__ # Reset stdout redirection\\r\\n\\t\\tos.remove(\\\"test_slpi_cwro.txt\\\") # Delete temporary output file if test is successful\\r\",\n \"def collecte_docs(self, chercheur, overwrite=False): # self,\\n init = overwrite # If True, data persistence is lost when references are updated\\n docs = hal.find_publications(chercheur[\\\"halId_s\\\"], \\\"authIdHal_s\\\")\\n\\n progress_recorder = ProgressRecorder(self)\\n progress_recorder.set_progress(0, len(docs), description=\\\"récupération des données HAL\\\")\\n # Insert documents collection\\n for num, doc in enumerate(docs):\\n doc[\\\"country_colaboration\\\"] = location_docs.generate_countrys_fields(doc)\\n doc = doi_enrichissement.docs_enrichissement_doi(doc)\\n if \\\"fr_abstract_s\\\" in doc.keys():\\n if isinstance(doc[\\\"fr_abstract_s\\\"], list):\\n doc[\\\"fr_abstract_s\\\"] = \\\"/n\\\".join(doc[\\\"fr_abstract_s\\\"])\\n if len(doc[\\\"fr_abstract_s\\\"]) > 100:\\n doc[\\\"fr_entites\\\"] = keyword_enrichissement.return_entities(\\n doc[\\\"fr_abstract_s\\\"], \\\"fr\\\"\\n )\\n doc[\\\"fr_teeft_keywords\\\"] = keyword_enrichissement.keyword_from_teeft(\\n doc[\\\"fr_abstract_s\\\"], \\\"fr\\\"\\n )\\n if \\\"en_abstract_s\\\" in doc.keys():\\n if isinstance(doc[\\\"en_abstract_s\\\"], list):\\n doc[\\\"en_abstract_s\\\"] = \\\"/n\\\".join(doc[\\\"en_abstract_s\\\"])\\n if len(doc[\\\"en_abstract_s\\\"]) > 100:\\n doc[\\\"en_entites\\\"] = keyword_enrichissement.return_entities(\\n doc[\\\"en_abstract_s\\\"], \\\"en\\\"\\n )\\n doc[\\\"en_teeft_keywords\\\"] = keyword_enrichissement.keyword_from_teeft(\\n doc[\\\"en_abstract_s\\\"], \\\"en\\\"\\n )\\n\\n doc[\\\"_id\\\"] = doc[\\\"docid\\\"]\\n doc[\\\"validated\\\"] = True\\n\\n doc[\\\"harvested_from\\\"] = \\\"researcher\\\"\\n\\n doc[\\\"harvested_from_ids\\\"] = []\\n doc[\\\"harvested_from_label\\\"] = []\\n\\n #\\n #\\n # print(doc[\\\"authorship\\\"], doc ['authLastName_s'])\\n\\n if len(doc[\\\"authIdHal_s\\\"]) != len(doc[\\\"authLastName_s\\\"]):\\n # print (\\\"elastichal.py : test d'autorat no good\\\")\\n # test sur le nom complet...\\n nom = [\\n truc\\n for truc in doc[\\\"authLastName_s\\\"]\\n if chercheur[\\\"lastName\\\"].lower() in truc.lower()\\n ] # pour les récemment mariés qui auraient un nom composé...\\n # Après si 'lun des co-auteur porte le même nom...\\n if len(nom) > 0:\\n nom = nom[0].title()\\n try:\\n if doc[\\\"authLastName_s\\\"].index(nom) == 0: # premier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"firstAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n elif (\\n doc[\\\"authLastName_s\\\"].index(nom) == len(doc[\\\"authLastName_s\\\"]) - 1\\n ): # dernier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"lastAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n except ValueError:\\n doc[\\\"authorship\\\"] = []\\n else:\\n doc[\\\"authorship\\\"] = []\\n elif chercheur[\\\"halId_s\\\"] in doc[\\\"authIdHal_s\\\"]:\\n if doc[\\\"authIdHal_s\\\"].index(chercheur[\\\"halId_s\\\"]) == 0:\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"firstAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n elif (\\n doc[\\\"authIdHal_s\\\"].index(chercheur[\\\"halId_s\\\"]) == len(doc[\\\"authIdHal_s\\\"]) - 1\\n ): # dernier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"lastAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n else:\\n doc[\\\"authorship\\\"] = []\\n else:\\n doc[\\\"authorship\\\"] = []\\n\\n doc[\\\"harvested_from_ids\\\"].append(chercheur[\\\"halId_s\\\"])\\n\\n # historique d'appartenance du docId\\n # pour attribuer les bons docs aux chercheurs\\n # harvet_history.append({'docid': doc['docid'], 'from': row['halId_s']})\\n #\\n # for h in harvet_history:\\n # if h['docid'] == doc['docid']:\\n # if h['from'] not in doc[\\\"harvested_from_ids\\\"]:\\n # doc[\\\"harvested_from_ids\\\"].append(h['from'])\\n\\n doc[\\\"records\\\"] = []\\n\\n doc[\\\"MDS\\\"] = utils.calculate_mds(doc)\\n\\n try:\\n should_be_open = utils.should_be_open(doc)\\n if should_be_open == 1:\\n doc[\\\"should_be_open\\\"] = True\\n if should_be_open == -1:\\n doc[\\\"should_be_open\\\"] = False\\n\\n if should_be_open == 1 or should_be_open == 2:\\n doc[\\\"isOaExtra\\\"] = True\\n elif should_be_open == -1:\\n doc[\\\"isOaExtra\\\"] = False\\n except IndexError:\\n print(\\\"publicationDate_tdate error ?\\\")\\n doc[\\\"Created\\\"] = datetime.datetime.now().isoformat()\\n\\n if not init: # récupération de l'existant pour ne pas écraser\\n field = \\\"_id\\\"\\n doc_param = esActions.scope_p(field, doc[\\\"_id\\\"])\\n\\n if not es.indices.exists(\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\"\\n ): # -researchers\\\" + row[\\\"ldapId\\\"] + \\\"-documents\\n print(\\\"exception \\\", chercheur[\\\"labHalId\\\"], chercheur[\\\"ldapId\\\"])\\n\\n res = es.search(\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\",\\n body=doc_param,\\n ) # -researchers\\\" + row[\\\"ldapId\\\"] + \\\"-documents\\n\\n if len(res[\\\"hits\\\"][\\\"hits\\\"]) > 0:\\n doc[\\\"validated\\\"] = res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"validated\\\"]\\n if \\\"authorship\\\" in res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"]:\\n doc[\\\"authorship\\\"] = res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"authorship\\\"]\\n\\n if (\\n res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"modifiedDate_tdate\\\"]\\n != doc[\\\"modifiedDate_tdate\\\"]\\n ):\\n doc[\\\"records\\\"].append(\\n {\\n \\\"beforeModifiedDate_tdate\\\": doc[\\\"modifiedDate_tdate\\\"],\\n \\\"MDS\\\": res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"MDS\\\"],\\n }\\n )\\n\\n else:\\n doc[\\\"validated\\\"] = True\\n progress_recorder.set_progress(num, len(docs), description=\\\"(récolte)\\\")\\n progress_recorder.set_progress(num, len(docs), description=\\\"(indexation)\\\")\\n helpers.bulk(\\n es,\\n docs,\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\",\\n refresh=\\\"wait_for\\\",\\n )\\n\\n return chercheur # au cas où\",\n \"def exposedSurf(self):\\n if self.precision:\\n h = self.evaluations.exposedWing.edges[1].point1.x # height of trapezoid\\n B = self.chordRootW # major base of trapezoid\\n b = self.evaluations.chordIntersected.edges[1].length # minor base of trapezoid\\n internalS = 2 * (0.5 * (b + B) * h) # wing surface internal at fuselage\\n return self.surfaceW - internalS\\n else:\\n return self.surfaceW - self.fuselageDiameter * self.cMACW # first guess for a faster evaluation\",\n \"def v(w,s):\\n return w\",\n \"def init_ngrams(self):\\n self.wv.ngrams = {}\\n all_ngrams = []\\n self.wv.syn0 = np.zeros((len(self.wv.vocab), self.vector_size), dtype=REAL)\\n\\n for w, vocab in self.wv.vocab.items():\\n all_ngrams += compute_ngrams(w, self.wv.min_n, self.wv.max_n)\\n self.wv.syn0[vocab.index] += np.array(self.wv.syn0_ngrams[vocab.index])\\n\\n all_ngrams = set(all_ngrams)\\n self.num_ngram_vectors = len(all_ngrams)\\n ngram_indices = []\\n for i, ngram in enumerate(all_ngrams):\\n ngram_hash = ft_hash(ngram)\\n ngram_indices.append(len(self.wv.vocab) + ngram_hash % self.bucket)\\n self.wv.ngrams[ngram] = i\\n self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)\\n\\n ngram_weights = self.wv.syn0_ngrams\\n\\n logger.info(\\n \\\"loading weights for %s words for fastText model from %s\\\",\\n len(self.wv.vocab), self.file_name\\n )\\n\\n for w, vocab in self.wv.vocab.items():\\n word_ngrams = compute_ngrams(w, self.wv.min_n, self.wv.max_n)\\n for word_ngram in word_ngrams:\\n self.wv.syn0[vocab.index] += np.array(ngram_weights[self.wv.ngrams[word_ngram]])\\n\\n self.wv.syn0[vocab.index] /= (len(word_ngrams) + 1)\\n logger.info(\\n \\\"loaded %s weight matrix for fastText model from %s\\\",\\n self.wv.syn0.shape, self.file_name\\n )\",\n \"def stop_word(w): # local feature\\n return (w in swl)\",\n \"def compare_wavs_length(c_wv, s_wv):\\n\\n # If the style wav is shorter than the content wav, exit in error\\n if s_wv.shape[0] < c_wv.shape[0]:\\n raise WavError(\\\"The style wav must be as long or longer than the content wav\\\")\\n\\n # If the style wav is longer, truncate it to match the content length\\n elif s_wv.shape[0] > c_wv.shape[0]:\\n print(\\\"Truncating style wav to match content wav length\\\")\\n s_wv = np.copy(s_wv[:c_wv.shape[0],:])\\n\\n return s_wv\",\n \"def build_vocab(self, corpus):\\n if self.vocabulary_counts != None:\\n logger.debug(\\\"building vocabulary from provided frequency map\\\")\\n vocab = self.vocabulary_counts\\n else:\\n logger.debug(\\\"default vocabulary building\\\")\\n super(Skipgram, self).build_vocab(corpus)\\n return\\n\\n # assign a unique index to each word\\n self.vocab, self.index2word = {}, []\\n\\n for word, count in vocab.iteritems():\\n v = Vocab()\\n v.count = count\\n if v.count >= self.min_count:\\n v.index = len(self.vocab)\\n self.index2word.append(word)\\n self.vocab[word] = v\\n\\n logger.debug(\\\"total %i word types after removing those with count<%s\\\" % (len(self.vocab), self.min_count))\\n\\n if self.hs:\\n # add info about each word's Huffman encoding\\n self.create_binary_tree()\\n if self.negative:\\n # build the table for drawing random words (for negative sampling)\\n self.make_table()\\n # precalculate downsampling thresholds\\n self.precalc_sampling()\\n self.reset_weights()\",\n \"def calc_doc_ret_MAP():\\n \\n# docs_norm_scores_dicts_path = linux_base_path+\\\"/docs_norm_scores_dicts\\\"\\n claim_rel_docno_dict = read_pickle(\\\"claim_rel_docno_dict\\\") #key is clm, value is a set of the relevant docno\\n# nDCG_MAP_res = base_path +\\\"\\\\\\\\nDCG_MAP_res\\\\\\\\\\\"\\n# docs_norms_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\\\\\\\\\"\\n docs_norms_path = linux_base_path+\\\"/docs_norm_scores_dicts/\\\"\\n nDCG_MAP_res = linux_base_path +\\\"/nDCG_MAP_res/\\\"\\n \\n AP_cut_off = 1000\\n k_val = 100\\n p = 10\\n log = open(\\\"calc_doc_avg_nDCG_MAP_log_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),\\\"wb\\\")\\n res_file = open(nDCG_MAP_res+\\\"doc_ret_nDCG_MAP_res_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),\\\"wb\\\")\\n# each_params_AVGnDCG_MAP_dict = {} #key is alpha,beta,k_docs,lambda and val is the avg nDCG and MAP across all claims together\\n each_params_MAP_dict = {}\\n# NDCG_AP_all_claims_all_param_values = {}\\n AP_all_claims_all_param_values = {}\\n best_avg_nDCG = 0\\n best_MAP = 0 #across all claims in a given configuration, find the max measures\\n \\n# docs_norms_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\\\\\\\\\"\\n claims_dict = read_pickle(\\\"claim_dict\\\")\\n #count the number of sentences that were retrived that are in the true data....sum for each claim, then average.\\n \\n \\n for alpha in range(0,11,1): #change just for test!\\n for beta in range(0,10,1):\\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\\n NDCG_all_claims= {} #key is a claim, value is the nDCG\\n AP_all_claims= {} \\n AP_cut_off = 1000\\n curr_filename = docs_norms_path+\\\"clm_key_ranked_list_of_docs_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)\\n clm_key_ranked_list_of_docs_baseline = read_pickle(curr_filename) #key is qID and docid\\n #need to turn it to a list of docs\\n for clm in claim_list:\\n try:\\n# nDCG_score = utils_linux.calc_doc_emp_NDCG(curr_source,str(clm),clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]],p)\\n# NDCG_all_claims[clm] = nDCG_score\\n AP_score = utils_linux.calc_doc_AP_relevance(AP_cut_off,curr_source,clm,clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]])\\n AP_all_claims[clm] = AP_score\\n AP_all_claims_all_param_values[clm,alpha_f,beta_f,k_val] = AP_score\\n except Exception as err: \\n log.write('problem in calculations: in source: '+ curr_source+' in clm '+ claims_dict[str(clm)]+\\\" alpha:\\\"+str(alpha_f)+ \\\"beta:\\\"+str(beta_f)+\\\" \\\\n\\\" ) \\n for arg in err.args:\\n log.write(arg+\\\" \\\") \\n log.write(\\\"\\\\n\\\") \\n# average_NDCG = float(float(sum(NDCG_all_claims.values()))/float(len(NDCG_all_claims))) #across all claims...\\n# if average_NDCG > best_avg_nDCG:\\n# best_avg_nDCG = average_NDCG\\n# best_avg_nDCG_configuration = (alpha_f,beta_f,k_val)\\n MAP = float(float(sum(AP_all_claims.values()))/float(len(AP_all_claims)))\\n if MAP > best_MAP:\\n best_MAP = MAP\\n best_MAP_configuration = (alpha_f,beta_f,k_val)\\n each_params_MAP_dict[alpha_f,beta_f,k_val] = MAP\\n utils_linux.save_pickle(nDCG_MAP_res+\\\"doc_ret_NDCG_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),NDCG_all_claims)\\n utils_linux.save_pickle(nDCG_MAP_res+\\\"doc_ret_AP_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val),AP_all_claims)\\n# res_file.write(\\\"alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"|\\\"+\\\"AnDCG_\\\"+str(average_NDCG)+\\\"_MAP_\\\"+str(MAP)+\\\"\\\\n\\\")\\n res_file.write(\\\"alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"|_MAP_\\\"+str(MAP)+\\\"\\\\n\\\")\\n save_pickle(nDCG_MAP_res+\\\"doc_ret_NDCG_AP_all_claims_all_param_values_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),AP_all_claims_all_param_values)\\n save_pickle(nDCG_MAP_res+\\\"doc_ret_each_params_AVGnDCG_MAP_dict_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),each_params_MAP_dict)\\n# best_row = \\\"best_avg_nDCG|\\\"+str(best_avg_nDCG)+\\\"|best_avg_nDCG_configuration|\\\"+str(best_avg_nDCG_configuration[0])+\\\",\\\"+str(best_avg_nDCG_configuration[1])+\\\",\\\"+str(best_avg_nDCG_configuration[3])+\\\",\\\"+str(best_avg_nDCG_configuration[2])+\\\"|\\\"\\n best_row = \\\"best_MAP|\\\" +str(best_MAP)+\\\"|best_MAP_configuration|\\\"+str(best_MAP_configuration[0])+\\\",\\\"+str(best_MAP_configuration[1])+\\\",\\\"+str(best_MAP_configuration[2])\\n res_file.write(best_row)\\n res_file.close()\\n log.close()\",\n \"def documento():\\r\\n\\tpass\",\n \"def qwf(self, vw, ev, gp, psi_l, lai, dt):\\n\\t\\t#if the amount of water in storage is less than amount that will be absorbed by plant in timestep dt, then what's left will be absorbed \\n\\t qw = (self.gwf(self.psi_wf(self.vw,self.d1, self.d1, self.ns, self.tl), self.H, self.J)*(self.psi_wf(self.vw, self.d1, self.d1, self.ns, self.tl) - (ev*(1. - self.F_CAP))/(lai*gp) - psi_l)*lai)\\n\\t if self.vw == 0:\\n\\t return 0.\\n\\t elif self.vw*10**6 <= qw*dt:\\n\\t return (self.vw*10**6/dt)\\n\\t else:\\n\\t return qw\",\n \"def _compute_export_in_woo(self):\\n for rec in self:\\n rec.ks_export_in_woo = bool(rec.ks_woo_id)\",\n \"def test_continue_build() -> None:\\n tknzr = WsTknzr(is_uncased=True, max_vocab=-1, min_count=0)\\n tknzr.build_vocab(['a'])\\n tknzr.build_vocab(['b'])\\n tknzr.build_vocab(['c'])\\n assert tknzr.tk2id == {\\n BOS_TK: BOS_TKID,\\n EOS_TK: EOS_TKID,\\n PAD_TK: PAD_TKID,\\n UNK_TK: UNK_TKID,\\n 'a': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 1,\\n 'b': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 2,\\n 'c': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 3,\\n }\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def evaluate():\\n global dictionary, wv\\n count = 0\\n # To save the scores by distance and similarity\\n scores = np.zeros(6)\\n similar = np.zeros(6)\\n itr = len(dictionary)\\n logging.info('running evaluation for {0} samples'.format(itr))\\n for key in dictionary:\\n progress = (count / itr) * 100\\n d = dictionary[key].split('resource/')\\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\\n try:\\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\\n dtype=np.float32)\\n except KeyError:\\n itr -= 1\\n continue\\n if np.any(np.isnan(r)):\\n itr -= 1\\n continue\\n else:\\n if r.ndim == 2:\\n try:\\n # Mean of vector containing all word vectors\\n # obtained from abstract.\\n r = r.mean(axis=0).reshape(1, -1)\\n \\n # Obtain the vectors for the entity\\n mean_vec = mean_encoder(dictionary[key])\\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\\n mean_dist_vec = distance_encoder(dictionary[key])\\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\\n title_vec = title_mean(key)\\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\\n abstract_vec = abstract_encoder(key)\\n abstract_vec = abstract_vec.reshape(1, -1)\\n abstract_vec = abstract_vec / norm(abstract_vec)\\n random_vec = np.random.randn(100).reshape(1, -1)\\n zero_vec = np.zeros(100).reshape(1, -1)\\n \\n # Score the entity vectors\\n scores[0] += norm(r - mean_vec)\\n scores[1] += norm(r - mean_dist_vec)\\n scores[2] += norm(r - title_vec)\\n scores[3] += norm(r - abstract_vec)\\n scores[4] += norm(r - random_vec)\\n scores[5] += norm(r - zero_vec)\\n similar[0] += cosine_similarity(r, mean_vec)\\n similar[1] += cosine_similarity(r, mean_dist_vec)\\n similar[2] += cosine_similarity(r, title_vec)\\n similar[3] += cosine_similarity(r, abstract_vec)\\n similar[4] += cosine_similarity(r, random_vec)\\n similar[5] += cosine_similarity(r, zero_vec)\\n count += 1\\n print(count, end='\\\\r')\\n except (ValueError, KeyError) as _:\\n itr -= 1\\n continue\\n else:\\n itr -= 1\\n continue\\n # Normalize the scores to get a better\\n # comparison against the baselines.\\n scores = scores / norm(scores)\\n similar = similar / norm(similar)\\n print_summary(scores, similar)\",\n \"def _derW(self, w, x, y, z):\\n if _isscalar(w):\\n w_pos = max(min(self.wSearchFunc(self.w_list, w), self.w_n - 1), 1)\\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\\n else:\\n w_pos = self.wSearchFunc(self.w_list, w)\\n w_pos[w_pos < 1] = 1\\n w_pos[w_pos > self.w_n - 1] = self.w_n - 1\\n x_pos = self.xSearchFunc(self.x_list, x)\\n x_pos[x_pos < 1] = 1\\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\\n y_pos = self.ySearchFunc(self.y_list, y)\\n y_pos[y_pos < 1] = 1\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n z_pos = self.zSearchFunc(self.z_list, z)\\n z_pos[z_pos < 1] = 1\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n i = w_pos # for convenience\\n j = x_pos\\n k = y_pos\\n l = z_pos\\n beta = (x - self.x_list[j - 1]) / (self.x_list[j] - self.x_list[j - 1])\\n gamma = (y - self.y_list[k - 1]) / (self.y_list[k] - self.y_list[k - 1])\\n delta = (z - self.z_list[l - 1]) / (self.z_list[l] - self.z_list[l - 1])\\n dfdw = (\\n (\\n (1 - beta)\\n * (1 - gamma)\\n * (1 - delta)\\n * self.f_values[i, j - 1, k - 1, l - 1]\\n + (1 - beta) * (1 - gamma) * delta * self.f_values[i, j - 1, k - 1, l]\\n + (1 - beta) * gamma * (1 - delta) * self.f_values[i, j - 1, k, l - 1]\\n + (1 - beta) * gamma * delta * self.f_values[i, j - 1, k, l]\\n + beta * (1 - gamma) * (1 - delta) * self.f_values[i, j, k - 1, l - 1]\\n + beta * (1 - gamma) * delta * self.f_values[i, j, k - 1, l]\\n + beta * gamma * (1 - delta) * self.f_values[i, j, k, l - 1]\\n + beta * gamma * delta * self.f_values[i, j, k, l]\\n )\\n - (\\n (1 - beta)\\n * (1 - gamma)\\n * (1 - delta)\\n * self.f_values[i - 1, j - 1, k - 1, l - 1]\\n + (1 - beta)\\n * (1 - gamma)\\n * delta\\n * self.f_values[i - 1, j - 1, k - 1, l]\\n + (1 - beta)\\n * gamma\\n * (1 - delta)\\n * self.f_values[i - 1, j - 1, k, l - 1]\\n + (1 - beta) * gamma * delta * self.f_values[i - 1, j - 1, k, l]\\n + beta\\n * (1 - gamma)\\n * (1 - delta)\\n * self.f_values[i - 1, j, k - 1, l - 1]\\n + beta * (1 - gamma) * delta * self.f_values[i - 1, j, k - 1, l]\\n + beta * gamma * (1 - delta) * self.f_values[i - 1, j, k, l - 1]\\n + beta * gamma * delta * self.f_values[i - 1, j, k, l]\\n )\\n ) / (self.w_list[i] - self.w_list[i - 1])\\n return dfdw\",\n \"def _get_context_from_gdoc(self, key):\\n try:\\n content = self.export_xlsx(key)\\n data = process_xlsx(content)\\n if 'values' in data:\\n data = copy_global_values(data)\\n return data\\n except BadStatusLine:\\n # Stale connection, reset API and data\\n puts(\\\"Connection reset, reloading drive API\\\")\\n self.client = get_drive_api()\\n return self._get_context_from_gdoc(key)\",\n \"def test_validate_wc3(self):\\r\\n assert self.wc2_tree != 0\",\n \"def w(self): # pylint: disable=invalid-name\\n return self._w\",\n \"def vwf(self, vw, ev, gp, psi_l, lai, dt):\\n\\t return min(vw - self.qwf(self.vw, self.th, self.gp, self.psi_l, self.LAI, dt)*dt/10.**6, self.ZW)\",\n \"def processVS(self, model=\\\"okapi\\\", l = 0.5):\\n self.results[model] = {}\\n for query in self.queries:\\n res = {}\\n for doc in query.docs.values():\\n sum_otf = 0.0\\n for term in doc.terms:\\n if model == \\\"okapi\\\":\\n sum_otf += self.okapiTF(term.tf, doc.dlen, self.avgdlen)\\n if model == \\\"tfidf\\\":\\n sum_otf += self.tfidf(term.tf, term.df, doc.dlen, self.avgdlen, self.num_docs)\\n if model == \\\"bm25\\\":\\n sum_otf += self.bm25(term.tf, term.df, query.query_tf[term.term], doc.dlen, self.avgdlen, self.num_docs)\\n res[doc.id] = sum_otf\\n self.results[model][query.id] = res\",\n \"def computeProportionWings(self):\\n self.ws_me_pointsA = []\\n self.ws_me_pointsIy = []\\n self.ws_me_pointsIz = []\\n self.ws_me_pointsJ = []\\n for i in range(self.nWings):\\n wingIndex = i+1\\n wingNnodes = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"FEM\\\"][\\\"nodesFEM\\\"]\\n if self.tigl.wingGetSymmetry(i+1) != 0:\\n wingNnodes = 2*wingNnodes - 1\\n inputMaxA = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"A\\\"]\\n inputMaxIy = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"Iy\\\"]\\n inputMaxIz = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"Iz\\\"]\\n inputMaxJ = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"J\\\"]\\n inputInterpolationType = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"FEM\\\"][\\\"mechanicalInterpolationType\\\"]\\n index = np.argmax(self.ws_me_pointsInitArea[i])\\n wingMaxArea = self.ws_me_pointsInitArea[i][index]\\n\\n if inputInterpolationType == \\\"constant\\\":\\n exposant = 0\\n elif inputInterpolationType == \\\"linear\\\":\\n exposant = 1\\n elif inputInterpolationType == \\\"quadratic\\\":\\n exposant = 2\\n else:\\n logger.error(\\\"Wing mechanical properties distribution is\\\")\\n logger.error(\\\"wrong. Accepted values are \\\\\\\"constant\\\\\\\",\\\")\\n logger.error(\\\"\\\\\\\"linear\\\\\\\", \\\\\\\"quadratic\\\\\\\"\\\")\\n sys.exit()\\n\\n coef = np.empty(wingNnodes)\\n self.w_m_pointsA = np.empty(wingNnodes)\\n self.w_m_pointsIy = np.empty(wingNnodes)\\n self.w_m_pointsIz = np.empty(wingNnodes)\\n self.w_m_pointsJ = np.empty(wingNnodes)\\n for j in range(wingNnodes):\\n coef[j] = self.ws_me_pointsInitArea[i][j]/wingMaxArea\\n self.w_m_pointsA[j] = inputMaxA * coef[j]\\n self.w_m_pointsIy[j] = inputMaxIy * coef[j]**exposant\\n self.w_m_pointsIz[j] = inputMaxIz * coef[j]**exposant\\n self.w_m_pointsJ[j] = inputMaxJ * coef[j]**exposant\\n self.ws_me_pointsA.append(self.w_m_pointsA)\\n self.ws_me_pointsIy.append(self.w_m_pointsIy)\\n self.ws_me_pointsIz.append(self.w_m_pointsIz)\\n self.ws_me_pointsJ.append(self.w_m_pointsJ)\",\n \"def unknown(self, w):\\n return True\",\n \"def generate_wordcloud():\\r\\n # \\\"\\\"\\\"Join list into one string\\\"\\\"\\\"\\r\\n # unique_string = (\\\" \\\").join(prioritized)\\r\\n # wc = WordCloud(background_color=\\\"black\\\", width=2000, height=2000,contour_color=\\\"black\\\", max_words=30, relative_scaling=0.5, normalize_plurals=False).generate(unique_string)\\r\\n\\r\\n \\\"\\\"\\\"Generate word cloud based on dictionary\\\"\\\"\\\"\\r\\n wc = WordCloud(background_color=\\\"black\\\", width=2000, height=2000, contour_color=\\\"black\\\", max_words=30,\\r\\n relative_scaling=0.5, normalize_plurals=False).generate_from_frequencies(priority_dict)\\r\\n\\r\\n fig = plt.figure(figsize=(10, 7))\\r\\n fig.suptitle(\\\"Top 30 Most Visited Websites\\\")\\r\\n plt.imshow(wc, interpolation=\\\"bilinear\\\")\\r\\n plt.axis(\\\"on\\\")\\r\\n plt.show()\",\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 w(self):\\n return self._w\",\n \"def filter_w2v_nomenclature(w2vfilename,filter_nomenclature):\\n V = set(filter_nomenclature)\\n wordlist = []\\n veclist = [] \\n istream = open(w2vfilename)\\n istream.readline() #skips w2v header\\n for line in istream:\\n fields = line.split()\\n word = fields[0]\\n if word in V:\\n vec = np.array([float(elt) for elt in fields[1:]])\\n wordlist.append(word)\\n veclist.append(vec)\\n istream.close()\\n M = np.array(veclist)\\n return (wordlist,M)\",\n \"def __init__(self, w0=6):\\n self.w0 = w0\\n if w0 == 6:\\n # value of C_d from TC98\\n self.C_d = 0.776\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57836646","0.5585155","0.5435751","0.53624374","0.53587824","0.5239644","0.5201019","0.517548","0.50928926","0.5047328","0.5047328","0.5047328","0.50309426","0.5029931","0.5010414","0.50012654","0.4978423","0.49580443","0.4950043","0.49334282","0.49284104","0.49258792","0.49221966","0.48822728","0.48672223","0.4821451","0.47912726","0.47839433","0.4777881","0.47631","0.47618377","0.4746454","0.47339392","0.47266492","0.47236753","0.47226754","0.47175616","0.47166634","0.4710289","0.47078198","0.47018453","0.4698216","0.4691201","0.4686009","0.46789938","0.4676474","0.46748197","0.4670401","0.4654626","0.46416092","0.4628169","0.46280682","0.4624723","0.4622075","0.46211836","0.46146044","0.46105263","0.46066892","0.46021658","0.45929268","0.45779818","0.45626476","0.45415714","0.45387205","0.45298907","0.45291495","0.45288342","0.45269394","0.45260805","0.45250568","0.45246968","0.45244852","0.4523928","0.4522721","0.45223424","0.45157006","0.450869","0.4508614","0.45055145","0.45018455","0.44999272","0.44999272","0.44999272","0.44999272","0.44999272","0.44999272","0.4497952","0.44961214","0.4491726","0.44869766","0.4481867","0.44812363","0.44782493","0.44780573","0.44744962","0.44732437","0.44677693","0.4466934","0.44617814","0.44572055"],"string":"[\n \"0.57836646\",\n \"0.5585155\",\n \"0.5435751\",\n \"0.53624374\",\n \"0.53587824\",\n \"0.5239644\",\n \"0.5201019\",\n \"0.517548\",\n \"0.50928926\",\n \"0.5047328\",\n \"0.5047328\",\n \"0.5047328\",\n \"0.50309426\",\n \"0.5029931\",\n \"0.5010414\",\n \"0.50012654\",\n \"0.4978423\",\n \"0.49580443\",\n \"0.4950043\",\n \"0.49334282\",\n \"0.49284104\",\n \"0.49258792\",\n \"0.49221966\",\n \"0.48822728\",\n \"0.48672223\",\n \"0.4821451\",\n \"0.47912726\",\n \"0.47839433\",\n \"0.4777881\",\n \"0.47631\",\n \"0.47618377\",\n \"0.4746454\",\n \"0.47339392\",\n \"0.47266492\",\n \"0.47236753\",\n \"0.47226754\",\n \"0.47175616\",\n \"0.47166634\",\n \"0.4710289\",\n \"0.47078198\",\n \"0.47018453\",\n \"0.4698216\",\n \"0.4691201\",\n \"0.4686009\",\n \"0.46789938\",\n \"0.4676474\",\n \"0.46748197\",\n \"0.4670401\",\n \"0.4654626\",\n \"0.46416092\",\n \"0.4628169\",\n \"0.46280682\",\n \"0.4624723\",\n \"0.4622075\",\n \"0.46211836\",\n \"0.46146044\",\n \"0.46105263\",\n \"0.46066892\",\n \"0.46021658\",\n \"0.45929268\",\n \"0.45779818\",\n \"0.45626476\",\n \"0.45415714\",\n \"0.45387205\",\n \"0.45298907\",\n \"0.45291495\",\n \"0.45288342\",\n \"0.45269394\",\n \"0.45260805\",\n \"0.45250568\",\n \"0.45246968\",\n \"0.45244852\",\n \"0.4523928\",\n \"0.4522721\",\n \"0.45223424\",\n \"0.45157006\",\n \"0.450869\",\n \"0.4508614\",\n \"0.45055145\",\n \"0.45018455\",\n \"0.44999272\",\n \"0.44999272\",\n \"0.44999272\",\n \"0.44999272\",\n \"0.44999272\",\n \"0.44999272\",\n \"0.4497952\",\n \"0.44961214\",\n \"0.4491726\",\n \"0.44869766\",\n \"0.4481867\",\n \"0.44812363\",\n \"0.44782493\",\n \"0.44780573\",\n \"0.44744962\",\n \"0.44732437\",\n \"0.44677693\",\n \"0.4466934\",\n \"0.44617814\",\n \"0.44572055\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.50977534"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":12898,"cells":{"query":{"kind":"string","value":"usalbe only when g_wc was used to find pr_wv"},"document":{"kind":"string","value":"def get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode):\r\n cnt_list =[]\r\n for b, g_wc1 in enumerate(g_wc):\r\n pr_wn1 = len(pr_sql_i[b][\"conds\"])\r\n g_wn1 = g_wn[b]\r\n\r\n # Now sorting.\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx1 = argsort(array(g_wc1))\r\n elif mode == 'train':\r\n idx1 = list( range( g_wn1) )\r\n else:\r\n raise ValueError\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n flag = True\r\n for i_wn, idx11 in enumerate(idx1):\r\n g_wvi_str11 = str(g_sql_i[b][\"conds\"][idx11][2]).lower()\r\n pr_wvi_str11 = str(pr_sql_i[b][\"conds\"][i_wn][2]).lower()\r\n # print(g_wvi_str11)\r\n # print(pr_wvi_str11)\r\n # print(g_wvi_str11==pr_wvi_str11)\r\n if g_wvi_str11 != pr_wvi_str11:\r\n flag = False\r\n # print(g_wv1, g_wv11)\r\n # print(pr_wv1, pr_wv11)\r\n # input('')\r\n break\r\n if flag:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n\r\n return cnt_list"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _compute_wo(self):\n self.uom_id = self.wo_id.uom_id.id\n self.final_product_id = self.wo_id.final_product_id.id\n if not self.supplier_id:\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\n else:\n service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\n if service_ids:\n product_supp_rcs = self.env['product.supplierinfo'].search([('partner_id', '=', self.supplier_id.id), ('product_id', 'in', service_ids)])\n if product_supp_rcs:\n product_ids = [x.product_id.id for x in product_supp_rcs if x.product_id]\n else:\n product_ids = []\n else:\n product_ids = [] \n \n self.service_ids = product_ids\n \n # Permet de savoir si l'OT suivant est de sous-traitance et qu'il y a qu'un seul OT suivant\n no_direct_fp = True\n if self.wo_id.next_wo_ids and len(self.wo_id.next_wo_ids) == 1 and self.wo_id.next_wo_ids[0].is_subcontracting and self.wo_id.next_wo_ids[0].consumed_service_ids:\n no_direct_fp = False\n \n self.no_direct_fp = no_direct_fp","def convert_pr_wvi_to_string(pr_wvi, nlu_t, nlu_wp_t, wp_to_wh_index, nlu):\r\n pr_wv_str_wp = [] # word-piece version\r\n pr_wv_str = []\r\n for b, pr_wvi1 in enumerate(pr_wvi):\r\n pr_wv_str_wp1 = []\r\n pr_wv_str1 = []\r\n wp_to_wh_index1 = wp_to_wh_index[b]\r\n nlu_wp_t1 = nlu_wp_t[b]\r\n nlu_t1 = nlu_t[b]\r\n\r\n for i_wn, pr_wvi11 in enumerate(pr_wvi1):\r\n st_idx, ed_idx = pr_wvi11\r\n\r\n # Ad-hoc modification of ed_idx to deal with wp-tokenization effect.\r\n # e.g.) to convert \"butler cc (\" ->\"butler cc (ks)\" (dev set 1st question).\r\n pr_wv_str_wp11 = nlu_wp_t1[st_idx:ed_idx+1]\r\n pr_wv_str_wp1.append(pr_wv_str_wp11)\r\n\r\n st_wh_idx = wp_to_wh_index1[st_idx]\r\n ed_wh_idx = wp_to_wh_index1[ed_idx]\r\n pr_wv_str11 = nlu_t1[st_wh_idx:ed_wh_idx+1]\r\n\r\n pr_wv_str1.append(pr_wv_str11)\r\n\r\n pr_wv_str_wp.append(pr_wv_str_wp1)\r\n pr_wv_str.append(pr_wv_str1)\r\n\r\n return pr_wv_str, pr_wv_str_wp","def unknown(self, w):\n # WORK HERE!!","def _compute_wo(self):\n self.uom_id = self.wo_id.uom_id.id\n self.final_product_id = self.wo_id.final_product_id.id\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]","def get_wm_ws_Gx_bot(self):\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \n z_u_r = self.grid_dict['z_u_r']\n z_u_w = self.grid_dict['z_u_w']\n [Ly,N] = self.b.shape\n #---> j-loop\n for j in range(Ly): \n self.kbl[j] = N # initialize search\n #-> end j-loop\n\n #--> k-loop\n for k in range(N-1,0,-1):\n k_w = k\n k_r = k-1\n # --> j loop \n for j in range(Ly):\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\n self.kbl[j] = k_w\n\n #--> end k\n # --> end j\n\n\n '''\n Compute nondimenisonal shape function coefficeints Gx() by\n matching values and vertical derivatives of interior mixing\n coefficients at hbbl (sigma=1)\n '''\n\n self.Gm1_bot = np.zeros([Ly])\n self.dGm1_dS_bot = np.zeros([Ly])\n self.Gt1_bot = np.zeros([Ly])\n self.dGt1_dS_bot = np.zeros([Ly]) \n self.Av_bl_bot = np.zeros([Ly])\n self.dAv_bl_bot = np.zeros([Ly]) \n self.cff_up_bot = np.zeros([Ly])\n self.cff_dn_bot = np.zeros([Ly])\n\n\n\n\n\n self.wm_bot = np.zeros([Ly])\n self.ws_bot = np.zeros([Ly]) \n\n # CALCULATE ustar for the bottom based on bototm velocities\n \n \n \n # CALCULATE r_D\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \n u = self.u\n v_upts = TTTW_func.v2u(self.v)\n \n ubar = np.mean(u,axis=1)\n vbar = np.mean(v_upts,axis=1)\n\n # --> j loop\n for j in range(Ly):\n # turbulent velocity sclaes with buoyancy effects neglected\n if self.CD_SWITCH:\n # DEPTH AVERAGED APPROACH\n uref = u[j,0]\n vref = v_upts[j,0]\n ustar2 = self.C_D * (uref**2 + vref**2)\n else:\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\n wm = self.vonKar * np.sqrt(ustar2)\n ws = wm\n\n self.wm_bot[j] = wm\n self.ws_bot[j] = ws\n \n k_w = self.kbl[j] \n z_bl = z_u_w[j,0] + self.hbbl[j]\n\n if z_bl < z_u_w[j,k_w-1]:\n k_w = k_w-1\n\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl_bot[j] = Av_bl\n self.dAv_bl_bot[j] = dAv_bl\n\n\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\n\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])","def grounding_words(self, w):\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])","def wisdom(search_me, source, pdfurl, userid):\n ### source needs to be name of data source (\"arxiv\", \"google scholar\", \"doaj\")\n search_me = search_me.strip()\n # check if pdfurl has been found before\n pdf = db_summaries.find_one({\"url\": pdfurl})\n if pdf:\n text = pdf.get('text')\n summary = pdf.get('summary')\n topics = pdf.get('topics')\n # update in db if data is 1 days or older\n last_updated = datetime.utcnow() - pdf.get(\"last_updated\")\n last_updated_diff = last_updated.days\n if last_updated_diff > 1:\n search_term = db_search_terms.find_one({\"value\": search_me.lower()})\n search_id = search_term.get(\"_id\")\n data = {\"search_id\": search_id,\n \"url\": pdfurl, \"source\": source, \"text\": text,\n \"summary\": summary, \"topics\": topics, \"last_updated\": datetime.utcnow()}\n db_summaries.update({\"url\": pdfurl}, {\"$set\": data})\n else:\n pass\n else:\n text = wisdomaiengine.pdfdocumentextracter(pdfurl)\n summary = wisdomaiengine.summarisepdfdocument(text)\n topics = wisdomaiengine.wordcloud(search_me, text)\n if topics is None:\n topics = ['No Topics Found']\n # write data to arxiv collection\n search_term = db_search_terms.find_one({\"value\": search_me.lower()})\n search_id = search_term.get(\"_id\")\n data = {\"search_id\": search_id,\n \"url\": pdfurl,\n \"source\": source,\n \"text\": text,\n \"summary\": summary,\n \"topics\": topics,\n \"last_updated\": datetime.utcnow()}\n x = db_summaries.insert(data, check_keys=False)\n # return json\n summaryjson = jsonify(wisdomtopics=topics, wisdomsummary=summary)\n return summaryjson","def get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode):\r\n cnt_list =[]\r\n for b, g_wvi1 in enumerate(g_wvi):\r\n g_wc1 = g_wc[b]\r\n pr_wvi1 = pr_wvi[b]\r\n pr_wn1 = len(pr_wvi1)\r\n g_wn1 = g_wn[b]\r\n\r\n # Now sorting.\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx1 = argsort(array(g_wc1))\r\n elif mode == 'train':\r\n idx1 = list( range( g_wn1) )\r\n else:\r\n raise ValueError\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n flag = True\r\n for i_wn, idx11 in enumerate(idx1):\r\n g_wvi11 = g_wvi1[idx11]\r\n pr_wvi11 = pr_wvi1[i_wn]\r\n if g_wvi11 != pr_wvi11:\r\n flag = False\r\n # print(g_wv1, g_wv11)\r\n # print(pr_wv1, pr_wv11)\r\n # input('')\r\n break\r\n if flag:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n\r\n return cnt_list","def get_wotd():\n\treturn wotd","def _get_wred(self):\n return self.__wred","def _get_wred(self):\n return self.__wred","def _get_wred(self):\n return self.__wred","def svn_info_t_has_wc_info_get(svn_info_t_self): # real signature unknown; restored from __doc__\n pass","def get_warc(self):\n raise NotImplementedError()","def wing(self):\n return","def is_wcw(status):\n test_text = ' '.join(status['text'].lower().split()) # Remove capital letters and excessive whitespace/linebreaks\n usernames = ['just_to_say_bot', 'thisisjustbot', 'Dcd200S', 'willslostplum', 'sosweetbot', 'JustToSayBot', 'thatisjustplums', \\\n\t\t 'EatenBot', 'the_niche_bot', 'KristenCostel10', 'litabottal', 'pythonnina', 'alatest5', 'LisaRob96585017','Stilson28400122', \\\n\t\t 'JohnDun40217560','Cordelia28', 'Rick63556459', 'botsnthings', 'timbot301', 'Rachel53001595', 'NicholasMillma6', 'ThisIsJustTo1'\\\n\t\t'MayISay4', 'breakfast_plum', 'BotBot53368932'] # Block screen_names of known parody accounts\n if status['user']['screen_name'] not in usernames and all(u not in status['text'] for u in usernames) and 'Cheap Bots, Done Quick!' not in status['source']:\n if 'which you were probably' in test_text: # Capture parodies of the form\n return True\n elif 'plums' in test_text and 'icebox' in test_text: # Capture parodies of the content\n return True\n elif 'plum' in test_text and 'icebox' in test_text: # Capture singular 'plum'\n return True\n elif 'plums' in test_text and 'ice box' in test_text: #Capture 'ice box' with a space\n return True\n elif 'plum' in test_text and 'ice box' in test_text: \n return True\n elif 'William Carlos Williams'.lower() in test_text and 'plums' in test_text: #Capture mentions of WCW\n return True\n elif 'William Carlos Williams'.lower() in test_text and 'plum' in test_text:\n return True\n elif 'this is just to say' in test_text and 'that were in' in test_text: # Get only relevant instances of \"this is just to say\"\n return True\n elif 'this is just to say' in test_text and 'forgive me' in test_text:\n return True\n elif 'this is just to say' in test_text and 'and so' in test_text:\n return True\n elif 'so sweet and so cold' in test_text and 'the arms of the ocean' not in test_text: # Get 'so sweet and so cold' tweets that aren't quoting Florence and the Machine\n return True\n else:\n return False\n else:\n return False","def get_WS(w2v):\n # get set of MAX_NGRAM-grams in text\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 ngrams_in_data = set()\n for words in raw:\n for ngram in tweet_to_ngrams(words):\n ngrams_in_data.add(ngram)\n\n # load sentiment features from model\n clf_pipe = pickle.load(open(CLF_FNAME, 'rb')) # model\n\n vect = clf_pipe.best_estimator_.named_steps['vect']\n clf = clf_pipe.best_estimator_.named_steps['clf']\n\n features_to_sent_idx = vect.vocabulary_ # map from model features to sentiment index\n # currently, sentiment = 2 * (count_pos / (count_pos + count_neg)) - 1\n sentiments = clf.feature_count_[1,:] / np.sum(clf.feature_count_, axis=0) # in [0,1]\n sentiments = 2 * sentiments - 1 # rescale to [-1,1]\n\n features_to_sent = {feat: sentiments[idx] for (feat,idx) in features_to_sent_idx.items()}\n\n # build WS and ngram_idx_map for each MAX_NGRAM-gram in the text\n k = len(next(iter(w2v.values()))) # dimension of embedding\n WS = np.zeros(shape=(len(ngrams_in_data) + 1, k + MAX_NGRAM), dtype='float32')\n ngram_idx_map = {}\n\n index = 1 # first row is left 0, for padding in the cnn. This is also neutral sentiment.\n # For Vader Sentiment analysis\n# vader_analyzer = SentimentIntensityAnalyzer()\n\n\n for ngram in ngrams_in_data:\n ngram_idx_map[ngram] = index\n\n # set word embedding, note that unknown words already randomized in load_embedding \n words = ngram.split(' ')\n WS[index,:k] = w2v[words[-1]] # embedding of last word\n\n # set sentiment embedding\n for n in range(MAX_NGRAM): # for 1, 2, ... length ngrams\n sub_ngram = ' '.join(words[-1 - n:]) \n\n # Naive Bayes Sentiment feature --------------------------------\n sent = features_to_sent.get(sub_ngram, 0.0) # default to neutral 0\n # --------------------------------------------------------------\n\n# # TextBlob sentiment feature -----------------------------------\n# sent = TextBlob(sub_ngram).sentiment.polarity\n# # --------------------------------------------------------------\n\n# # Vader sentiment feature -------------------------------------\n# sent = vader_analyzer.polarity_scores(sub_ngram)['compound']\n# # -------------------------------------------------------------\n WS[index,k+n] = sent\n\n index += 1\n\n return WS, ngram_idx_map","def combined_wcs(self) -> BaseHighLevelWCS:","def get_cnt_sw_list(g_sc, g_sa, g_wn, g_wc, g_wo, g_wvi,\r\n pr_sc, pr_sa, pr_wn, pr_wc, pr_wo, pr_wvi,\r\n g_sql_i, pr_sql_i,\r\n mode):\r\n cnt_sc = get_cnt_sc_list(g_sc, pr_sc)\r\n cnt_sa = get_cnt_sc_list(g_sa, pr_sa)\r\n cnt_wn = get_cnt_sc_list(g_wn, pr_wn)\r\n cnt_wc = get_cnt_wc_list(g_wc, pr_wc)\r\n cnt_wo = get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode)\r\n if pr_wvi:\r\n cnt_wvi = get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode)\r\n else:\r\n cnt_wvi = [0]*len(cnt_sc)\r\n cnt_wv = get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode) # compare using wv-str which presented in original data.\r\n\r\n\r\n return cnt_sc, cnt_sa, cnt_wn, cnt_wc, cnt_wo, cnt_wvi, cnt_wv","def handlehtmlsearch_wok(querystring, keywordstring, searchlimit, cache, smartconstrain):\n mpsearch, keywords, constraints = handlehtmlsearch_mp(querystring, keywordstring, cache, smartconstrain)\n\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'rt') as record:\n try:\n wlist = json.load(record)\n except ValueError:\n wlist = {}\n\n searchtotal = 0\n for search in mpsearch:\n searchtotal += len(search)\n\n wokresults = []\n i = 0\n\n for search in mpsearch:\n for n in search:\n iterinput = []\n for m in n['unit_cell_formula'].keys():\n iterinput.append(m + str(int(n['unit_cell_formula'][m])))\n\n iterlist = list(itertools.permutations(iterinput))\n\n searchparam = 'topic:' + n['pretty_formula'] + ' or topic:' + n['full_formula']\n\n for term in iterlist:\n searchparam += ' or topic:' + ''.join(term)\n\n i += 1\n if n['material_id'] in wlist.keys() and cache:\n print('loading wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\n wokresults.append(wlist[n['material_id']])\n else:\n print('searching wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\n try:\n searchdata = searchWoKTools.getsearchdata(searchparam, searchlimit)\n except:\n with open('wokRecord.json', 'wt') as record:\n json.dump(wlist, record)\n raise\n\n searchdata[0].update(n)\n wlist[n['material_id']] = searchdata\n wokresults.append(searchdata)\n\n mpsearch, wokresults = searchWoKTools.removeconstrainedwok(mpsearch, wokresults, constraints)\n\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'wt') as record:\n json.dump(wlist, record)\n\n keyresults = []\n for search in wokresults:\n keyresults.append(searchWoKTools.getkeylist(search, keywords))\n\n return keywords, mpsearch, wokresults, keyresults","def pwgrwlfilter(self):\n return None","def treat_page(self):\n # let's define some basic variables\n urtext = self.current_page.text\n urlang = self.current_page.site.code\n urtitle = self.current_page.title()\n urcat = []\n eng_site = pywikibot.Site('en')\n eng_title = ''\n \n interDict = {}\n try:\n site = pywikibot.Site('ur', 'wikipedia')\n urpage = pywikibot.Page(site, urtitle)\n langlst = urpage.iterlanglinks()\n\n \n for i in langlst:\n lang = str(i.site).split(':')[1]\n interDict[lang] = i.title\n \n eng_title = interDict['en']\n except:\n pywikibot.output(u'\\03{lightred}Unable to fetch interwiki links!\\03{default}')\n return False\n \n site = pywikibot.Site('en', 'wikipedia')\n enpage = pywikibot.Page(site, eng_title)\n\n wikitext = enpage.get() \n wikicode = mwp.parse(wikitext)\n\n # Extracting sfn templates and converting them in REF tags\n sfnlist = []\n for template in wikicode.filter_templates():\n if template.name in ('sfn', 'sfn'):\n sfnlist.append(template)\n templ_rep = '<ref>' + str(template) + '</ref>'\n wikicode.replace(template , templ_rep)\n\n alltags = wikicode.filter_tags() \n reftags = {}\n \n def search(myDict, search1):\n for key, value in myDict.items():\n if search1 in value: \n return key \n \n i=1\n for tag in alltags:\n if tag.tag=='ref':\n if tag.attributes == []: # check if attributes list is empty\n refval='NoRefName' # Reference has no name so assigning \"NoRefName\"\n else:\n name = tag.attributes[0]\n refval = name.value\n \n if tag.contents is None:\n #conval = search(reftags,refval)\n #reftags[i] = (refval,reftags[conval][1])\n pass\n else: \n reftags[i] = (refval,tag.contents)\n i += 1\n\n dlinks = {}\n for k,v in reftags.items():\n dkey = 'و' + str(k) + 'و'\n dlinks[dkey] = '<ref>' + str(v[1]) + '</ref>'\n\n urtext = urpage.text\n for r in tuple(dlinks.items()):\n urtext = urtext.replace(*r)\n\n # newln = '\\n'\n # Using noreferences to add Reference template if not present\n self.norefbot = noreferences.NoReferencesBot(None)\n if self.norefbot.lacksReferences(urtext):\n urtext = self.norefbot.addReferences(urtext)\n else:\n urpage.text = urtext + '\\n'\n\n print(urpage.text)\n \n # save the page \n urpage.save(summary=self.summary, minor=False)\n #self.put_current(urpage.text, summary=self.summary)","def CC_wdw(self):\n # Setup param\n loc = 'TSdata'\n if 'single' == self.newParam['survey_type']:\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc).shape[0]\n elif 'multiple' == self.newParam['survey_type']:\n TS_group = dt.utilities.DB_group_names(self.Database, group_name = loc)[0]\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc+'/'+TS_group).shape[0]\n\n param = self.newParam\n\n # Assign TS processing length to end_wdws if given\n if param['end_wdws']:\n TS_sig_len = param['end_wdws']\n else:\n TS_sig_len = TS_len\n\n ERROR_MESSAGE = 'The length of a TS signal to be processed is', TS_sig_len, \\\n 'which is < end of the last window'\n\n # Calculate wdwPos for overlapping windows of ww_ol if wdwPos is False\n if param['wdwPos'][0] is False:\n # Error checks\n if TS_sig_len < self.newParam['ww'][0]:\n raise Warning(ERROR_MESSAGE)\n\n wdwStep = np.floor(param['ww'][0] *\n (100 - param['ww_ol']) / 100)\n\n if self.verbose: print('* Length fo TSdata', TS_len)\n\n max_wdwPos = TS_sig_len - param['ww'][0] + 1\n wdwStarts = np.arange(0 + param['sta_wdws'], max_wdwPos, wdwStep).astype(int)\n\n if self.verbose: print('* The step in window potions is %s sample points' % wdwStep)\n if self.verbose: print('* The max window postions is %s sample points'% max_wdwPos)\n\n param['wdwPos'] = [ [wdw_start, wdw_start + param['ww'][0]] for\n wdw_start in wdwStarts ]\n\n # Only update wdwPos structure if not already done so\n elif np.array(param['wdwPos'][0]).shape == ():\n param['wdwPos'] = [ [wdw_start, wdw_start + ww] for wdw_start,ww in\n zip(param['wdwPos'], param['ww'])]\n\n self.newParam['wdwPos'] = param['wdwPos']","def fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw):\n\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\n\tTocwf=Vk*Ck*Dk/GDen\n\treturn Tocwf","def buildWPriorTerm(self):\r\n\r\n # self.w_prior.shape == (minibatch size,)\r\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\r\n\r\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)","def wkt(self): # -> str:\n ...","def _new_wos_dict():\n wos_dict = {\n 'DI': None,\n 'TI': None,\n 'PY': None,\n 'SO': None,\n 'UT': None,\n 'DE': None,\n }\n\n return wos_dict","def wing_geom_eval(self, cpacs):\n\n log.info(\"---------- Analysing wing geometry ----------\")\n\n # Opening tixi and tigl\n tixi = cpacs.tixi\n tigl = cpacs.tigl\n\n # Counting wing number without symmetry --------------------------------------\n w_nb = tixi.getNamedChildrenCount(WINGS_XPATH, \"wing\")\n\n # INITIALIZATION 1 -----------------------------------------------------------\n self.w_nb = w_nb\n self.wing_nb = w_nb\n wing_plt_area_xz = []\n wing_plt_area_yz = []\n wingUID = []\n\n # Counting sections and segments----------------------------------------------\n b = 0\n for i in range(1, w_nb + 1):\n double = 1\n self.wing_sym.append(tigl.wingGetSymmetry(i))\n if self.wing_sym[i - 1] != 0:\n double = 2 # To consider the real amount of wing\n # when they are defined using symmetry\n self.wing_nb += 1\n self.wing_sec_nb.append(tigl.wingGetSectionCount(i))\n self.wing_seg_nb.append(tigl.wingGetSegmentCount(i))\n self.wing_vol.append(tigl.wingGetVolume(i) * double)\n\n self.wing_plt_area.append(tigl.wingGetReferenceArea(i, 1) * double) # x-y plane\n wing_plt_area_xz.append(tigl.wingGetReferenceArea(i, 2) * double) # x-z plane\n wing_plt_area_yz.append(tigl.wingGetReferenceArea(i, 3) * double) # y-z plane\n\n self.wing_tot_vol = self.wing_tot_vol + self.wing_vol[i - 1]\n wingUID.append(tigl.wingGetUID(i))\n self.wing_span.append(tigl.wingGetSpan(wingUID[i - 1]))\n a = np.amax(self.wing_span)\n # Evaluating the index that corresponds to the main wing\n if a > b:\n self.main_wing_index = i\n b = a\n\n # Checking segment and section connection and reordering them\n (\n self.wing_sec_nb,\n _,\n seg_sec,\n _,\n ) = self.wing_check_segment_connection(wing_plt_area_xz, wing_plt_area_yz, tigl)\n\n # INITIALIZATION 2 -----------------------------------------------------------\n\n max_wing_sec_nb = np.amax(self.wing_sec_nb)\n max_wing_seg_nb = np.amax(self.wing_seg_nb)\n wing_center_section_point = np.zeros((max_wing_sec_nb, w_nb, 3))\n self.wing_center_seg_point = np.zeros((max_wing_seg_nb, self.wing_nb, 3))\n self.wing_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\n self.wing_fuel_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\n self.wing_fuel_vol = 0\n self.wing_mac = np.zeros((4, w_nb))\n self.wing_sec_thickness = np.zeros((max_wing_sec_nb + 1, w_nb))\n\n # WING ANALYSIS --------------------------------------------------------------\n\n # Main wing plantform area\n self.wing_plt_area_main = self.wing_plt_area[self.main_wing_index - 1]\n\n # Wing: MAC,chords,thickness,span,plantform area ------------------------------\n\n for i in range(1, w_nb + 1):\n mac = tigl.wingGetMAC(wingUID[i - 1])\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, 1, 0.0, 0.0)\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, 1, 0.0, 1.0)\n self.wing_max_chord.append(\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\n )\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 0.0)\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 1.0)\n self.wing_min_chord.append(\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\n )\n for k in range(1, 5):\n self.wing_mac[k - 1][i - 1] = mac[k - 1]\n for jj in range(1, self.wing_seg_nb[i - 1] + 1):\n j = int(seg_sec[jj - 1, i - 1, 2])\n cle = tigl.wingGetChordPoint(i, j, 0.0, 0.0)\n self.wing_seg_vol[j - 1][i - 1] = tigl.wingGetSegmentVolume(i, j)\n lp = tigl.wingGetLowerPoint(i, j, 0.0, 0.0)\n up = tigl.wingGetUpperPoint(i, j, 0.0, 0.0)\n if np.all(cle == lp):\n L = 0.25\n else:\n L = 0.75\n if np.all(cle == up):\n U = 0.25\n else:\n U = 0.75\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, j, 0.0, L)\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, j, 0.0, U)\n wing_center_section_point[j - 1][i - 1][0] = (wplx + wpux) / 2\n wing_center_section_point[j - 1][i - 1][1] = (wply + wpuy) / 2\n wing_center_section_point[j - 1][i - 1][2] = (wplz + wpuz) / 2\n self.wing_sec_thickness[j - 1][i - 1] = np.sqrt(\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\n )\n j = int(seg_sec[self.wing_seg_nb[i - 1] - 1, i - 1, 2])\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, self.wing_seg_nb[i - 1], 1.0, L)\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, self.wing_seg_nb[i - 1], 1.0, U)\n self.wing_sec_thickness[j][i - 1] = np.sqrt(\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\n )\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][0] = (wplx + wpux) / 2\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][1] = (wply + wpuy) / 2\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][2] = (wplz + wpuz) / 2\n self.wing_sec_mean_thick.append(\n np.mean(self.wing_sec_thickness[0 : self.wing_seg_nb[i - 1] + 1, i - 1])\n )\n # Evaluating wing fuel tank volume in the main wings\n if abs(round(self.wing_plt_area[i - 1], 3) - self.wing_plt_area_main) < 0.001:\n tp_ratio = self.wing_min_chord[i - 1] / self.wing_max_chord[i - 1]\n ratio = round(tp_ratio * self.wing_plt_area[i - 1] / 100, 1)\n if ratio >= 1.0:\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.8, 2)\n elif ratio >= 0.5:\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.72, 2)\n else:\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.5, 2)\n for j in seg_sec[:, i - 1, 2]:\n if j == 0.0:\n break\n self.wing_fuel_seg_vol[int(j) - 1][i - 1] = round(\n (self.wing_seg_vol[int(j) - 1][i - 1] / (sum(self.wing_vol)))\n * self.wing_fuel_vol,\n 2,\n )\n if (\n self.wing_plt_area[i - 1] > wing_plt_area_xz[i - 1]\n and self.wing_plt_area[i - 1] > wing_plt_area_yz[i - 1]\n ):\n self.is_horiz.append(True)\n if self.wing_sym[i - 1] != 0:\n self.is_horiz.append(True)\n else:\n self.is_horiz.append(False)\n if self.wing_sym[i - 1] != 0:\n self.is_horiz.append(False)\n\n # Wing segment length evaluating function\n self.get_wing_segment_length(wing_center_section_point)\n\n # Evaluating the point at the center of each segment, the center\n # is placed at 1/4 of the chord, symmetry is considered.\n\n a = 0\n c = False\n for i in range(1, int(self.wing_nb) + 1):\n if c:\n c = False\n continue\n for jj in range(1, self.wing_seg_nb[i - a - 1] + 1):\n j = int(seg_sec[jj - 1, i - a - 1, 2])\n self.wing_center_seg_point[j - 1][i - 1][0] = (\n wing_center_section_point[j - 1][i - a - 1][0]\n + wing_center_section_point[j][i - a - 1][0]\n ) / 2\n self.wing_center_seg_point[j - 1][i - 1][1] = (\n wing_center_section_point[j - 1][i - a - 1][1]\n + wing_center_section_point[j][i - a - 1][1]\n ) / 2\n self.wing_center_seg_point[j - 1][i - 1][2] = (\n wing_center_section_point[j - 1][i - a - 1][2]\n + wing_center_section_point[j][i - a - 1][2]\n ) / 2\n if self.wing_sym[i - 1 - a] != 0:\n if self.wing_sym[i - 1 - a] == 1:\n symy = 1\n symx = 1\n symz = -1\n if self.wing_sym[i - 1 - a] == 2:\n symy = -1\n symx = 1\n symz = 1\n if self.wing_sym[i - 1 - a] == 3:\n symy = 1\n symx = -1\n symz = 1\n self.wing_center_seg_point[:, i, 0] = (\n self.wing_center_seg_point[:, i - 1, 0] * symx\n )\n self.wing_center_seg_point[:, i, 1] = (\n self.wing_center_seg_point[:, i - 1, 1] * symy\n )\n self.wing_center_seg_point[:, i, 2] = (\n self.wing_center_seg_point[:, i - 1, 2] * symz\n )\n c = True\n a += 1\n\n self.w_seg_sec = seg_sec\n\n self.wing_area = round(self.wing_plt_area_main, 3)\n\n log.info(\"---------------------------------------------\")\n log.info(\"--------------- Wing Results ----------------\")\n log.info(f\"Number of Wings [-]: {self.wing_nb}\")\n log.info(f\"Wing symmetry plane [-]: {self.wing_sym}\")\n log.info(f\"Number of wing sections (not counting symmetry) [-]: {self.wing_sec_nb}\")\n log.info(f\"Number of wing segments (not counting symmetry) [-]: {self.wing_seg_nb}\")\n log.info(f\"Wing Span [m]: {self.wing_span}\")\n log.info(f\"Wing MAC length [m]: {self.wing_mac[0,]}\")\n log.info(f\"Wing max chord length [m]: {self.wing_max_chord}\")\n log.info(f\"Wing min chord length [m]: {self.wing_min_chord}\")\n log.info(f\"Main wing plantform area [m^2]: {self.wing_plt_area_main}\")\n log.info(f\"Wings plantform area [m^2]: {self.wing_plt_area}\")\n log.info(f\"Volume of each wing [m^3]: {self.wing_vol}\")\n log.info(f\"Total wing volume [m^3]: {self.wing_tot_vol}\")\n log.info(f\"Wing volume for fuel storage [m^3]: {self.wing_fuel_vol}\")\n log.info(\"---------------------------------------------\")","def get_wo_mthly_smry(self, workorder_browse):\n wo_summary_data = []\n wo_check_dict = {}\n no = 0\n if workorder_browse:\n for work_rec in workorder_browse:\n if work_rec.state and work_rec.state == \"done\":\n no += 1\n identification = \"\"\n repair_line_data = \"\"\n if work_rec.vehicle_id:\n identification += work_rec.vehicle_id.name\n if work_rec.vehicle_id.f_brand_id:\n identification += \" \" + work_rec.vehicle_id.f_brand_id.name\n if work_rec.vehicle_id.model_id:\n identification += \" \" + work_rec.vehicle_id.model_id.name\n for repaire_line in work_rec.repair_line_ids:\n if repaire_line.complete is True:\n if (\n repaire_line.repair_type_id\n and repaire_line.repair_type_id.name\n ):\n repair_line_data += (\n repaire_line.repair_type_id.name + \", \"\n )\n if work_rec.parts_ids:\n for parts_line in work_rec.parts_ids:\n if work_rec.id in wo_check_dict.keys():\n parts_data = {\n \"no\": -1,\n \"location\": \"\",\n \"type\": \"\",\n \"wo\": \"\",\n \"identification\": \"\",\n \"vin\": \"\",\n \"plate_no\": \"\",\n \"work_performed\": \"\",\n \"part\": parts_line.product_id\n and parts_line.product_id.default_code\n or \"\",\n \"qty\": parts_line.qty or 0.0,\n \"uom\": parts_line.product_uom\n and parts_line.product_uom.name\n or \"\",\n }\n wo_summary_data.append(parts_data)\n else:\n wo_check_dict[work_rec.id] = work_rec.id\n parts_data = {\n \"no\": no,\n \"location\": work_rec.team_id\n and work_rec.team_id.name\n or \"\",\n \"type\": work_rec.main_type or \"\",\n \"wo\": work_rec.name or \"\",\n \"identification\": identification or \"\",\n \"vin\": work_rec.vehicle_id\n and work_rec.vehicle_id.vin_sn\n or \"\",\n \"plate_no\": work_rec.vehicle_id\n and work_rec.vehicle_id.license_plate\n or \"\",\n \"work_performed\": repair_line_data\n and repair_line_data[:-2]\n or \"\",\n \"part\": parts_line.product_id\n and parts_line.product_id.default_code\n or \"\",\n \"qty\": parts_line.qty or 0.0,\n \"uom\": parts_line.product_uom\n and parts_line.product_uom.name\n or \"\",\n }\n wo_summary_data.append(parts_data)\n else:\n parts_data = {\n \"no\": no,\n \"location\": work_rec.team_id\n and work_rec.team_id.name\n or \"\",\n \"type\": work_rec.main_type or \"\",\n \"wo\": work_rec.name or \"\",\n \"identification\": identification or \"\",\n \"vin\": work_rec.vehicle_id\n and work_rec.vehicle_id.vin_sn\n or \"\",\n \"plate_no\": work_rec.vehicle_id\n and work_rec.vehicle_id.license_plate\n or \"\",\n \"work_performed\": repair_line_data\n and repair_line_data[:-2]\n or \"\",\n \"vehicle_make\": \"\",\n \"qty\": \"\",\n \"uom\": \"\",\n }\n wo_summary_data.append(parts_data)\n if not wo_summary_data:\n msg = _(\n \"Warning! \\n\\\n No data Available for selected work order.\"\n )\n raise UserError(msg)\n return wo_summary_data","def analyzeWeights(self, occludedPortions):\r\n\t\treturn None","def update(self):\n self.wc.update()","def original_wcs(self):\n return self._owcs","def lookup(doc, wv):\n checked = []\n for word in doc:\n try:\n word in wv\n except KeyError:\n log.warning(\"Word not in model: %s\", word)\n continue\n checked.append(wv[word])\n vec = np.mean(checked, axis=0)\n return vec","def give_wv_units(wave):\n if not hasattr(wave, 'unit'):\n uwave = u.Quantity(wave, unit=u.AA)\n elif wave.unit is None:\n uwave = u.Quantity(wave, unit=u.AA)\n else:\n uwave = u.Quantity(wave)\n\n return uwave","def wrez2xml(self,newdoc,newroot):\n\t\twrez = newdoc.createElement('wrez')\n\t\twrez.setAttribute('hasChanged', str(self.hasChanged))\n\t\tnewroot.appendChild(wrez)\n\n\t\tpath = newdoc.createElement('path')\n\t\tpath.setAttribute('value', self.path)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('init_str')\n\t\tpath.setAttribute('value', self.init_str)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('hash_sha512')\n\t\tpath.setAttribute('value', self.hash_sha512)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('src_rip')\n\t\tpath.setAttribute('value', self.src_rip)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('quality')\n\t\tpath.setAttribute('value', self.quality)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('codec')\n\t\tpath.setAttribute('value', self.codec)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('language')\n\t\tpath.setAttribute('value', self.language)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('audio')\n\t\tpath.setAttribute('value', self.audio)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('encoder')\n\t\tpath.setAttribute('value', self.encoder)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('version')\n\t\tpath.setAttribute('value', self.version)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('extension')\n\t\tpath.setAttribute('value', self.extension)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('release_year')\n\t\tpath.setAttribute('value', self.release_year)\n\t\twrez.appendChild(path)\n\t\n\t\tpath = newdoc.createElement('title')\n\t\tpath.setAttribute('value', self.title)\n\t\twrez.appendChild(path)\n\n\t\tpath = newdoc.createElement('size')\n\t\tpath.setAttribute('value', str(self.size))\n\t\twrez.appendChild(path)\n\t\treturn wrez","def get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode):\r\n cnt_list=[]\r\n for b, g_wo1 in enumerate(g_wo):\r\n g_wc1 = g_wc[b]\r\n pr_wc1 = pr_wc[b]\r\n pr_wo1 = pr_wo[b]\r\n pr_wn1 = len(pr_wo1)\r\n g_wn1 = g_wn[b]\r\n\r\n if g_wn1 != pr_wn1:\r\n cnt_list.append(0)\r\n continue\r\n else:\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx = argsort(array(g_wc1))\r\n\r\n g_wo1_s = array(g_wo1)[idx]\r\n g_wo1_s = list(g_wo1_s)\r\n elif mode == 'train':\r\n # due to tearch forcing, no need to sort.\r\n g_wo1_s = g_wo1\r\n else:\r\n raise ValueError\r\n\r\n if type(pr_wo1) != list:\r\n raise TypeError\r\n if g_wo1_s == pr_wo1:\r\n cnt_list.append(1)\r\n else:\r\n cnt_list.append(0)\r\n return cnt_list","def onReload(self, event):\n\n\t\tself.wv.Reload()","def test_mlpi_cwro(self):\r\n\t\twith open(\"test_mlpi_cwro.txt\", \"w\") as test_mlpi_cwro_output:\r\n\t\t\tsys.stdout = test_mlpi_cwro_output\r\n\t\t\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=100, censor_words_one_pass=True)\r\n\t\twith open(\"test_mlpi_cwro.txt\", \"r\") as test_mlpi_cwro_output:\r\n\t\t\twhile True:\r\n\t\t\t\tline_output = test_mlpi_cwro_output.readline()\r\n\t\t\t\tline_correct = cc_test_prose.readline()\r\n\t\t\t\tself.assertEqual(line_output, line_correct)\r\n\t\t\t\tif line_correct == '':\r\n\t\t\t\t\tbreak\r\n\t\tcc_test_prose.seek(0)\r\n\t\tsys.stdout = sys.__stdout__\r\n\t\tos.remove(\"test_mlpi_cwro.txt\")","def primalrepair(self,wlc,wuc,wlx,wux): # 3\n if wlc is None:\n wlc_ = None\n else:\n try:\n wlc_ = memoryview(wlc)\n except TypeError:\n try:\n _tmparr_wlc = array.array(\"d\",wlc)\n except TypeError:\n raise TypeError(\"Argument wlc has wrong type\")\n else:\n wlc_ = memoryview(_tmparr_wlc)\n \n else:\n if wlc_.format != \"d\":\n wlc_ = memoryview(array.array(\"d\",wlc))\n \n if wlc_ is not None and len(wlc_) != self.getnumcon():\n raise ValueError(\"Array argument wlc has wrong length\")\n if wuc is None:\n wuc_ = None\n else:\n try:\n wuc_ = memoryview(wuc)\n except TypeError:\n try:\n _tmparr_wuc = array.array(\"d\",wuc)\n except TypeError:\n raise TypeError(\"Argument wuc has wrong type\")\n else:\n wuc_ = memoryview(_tmparr_wuc)\n \n else:\n if wuc_.format != \"d\":\n wuc_ = memoryview(array.array(\"d\",wuc))\n \n if wuc_ is not None and len(wuc_) != self.getnumcon():\n raise ValueError(\"Array argument wuc has wrong length\")\n if wlx is None:\n wlx_ = None\n else:\n try:\n wlx_ = memoryview(wlx)\n except TypeError:\n try:\n _tmparr_wlx = array.array(\"d\",wlx)\n except TypeError:\n raise TypeError(\"Argument wlx has wrong type\")\n else:\n wlx_ = memoryview(_tmparr_wlx)\n \n else:\n if wlx_.format != \"d\":\n wlx_ = memoryview(array.array(\"d\",wlx))\n \n if wlx_ is not None and len(wlx_) != self.getnumvar():\n raise ValueError(\"Array argument wlx has wrong length\")\n if wux is None:\n wux_ = None\n else:\n try:\n wux_ = memoryview(wux)\n except TypeError:\n try:\n _tmparr_wux = array.array(\"d\",wux)\n except TypeError:\n raise TypeError(\"Argument wux has wrong type\")\n else:\n wux_ = memoryview(_tmparr_wux)\n \n else:\n if wux_.format != \"d\":\n wux_ = memoryview(array.array(\"d\",wux))\n \n if wux_ is not None and len(wux_) != self.getnumvar():\n raise ValueError(\"Array argument wux has wrong length\")\n res = self.__obj.primalrepair(wlc_,wuc_,wlx_,wux_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def primalrepair(self,wlc_,wuc_,wlx_,wux_):\n _wlc_minlength = self.getnumcon()\n if self.getnumcon() > 0 and wlc_ is not None and len(wlc_) != self.getnumcon():\n raise ValueError(\"Array argument wlc is not long enough: Is %d, expected %d\" % (len(wlc_),self.getnumcon()))\n if isinstance(wlc_, numpy.ndarray) and wlc_.dtype is numpy.dtype(numpy.float64) and wlc_.flags.contiguous:\n _wlc_copyarray = False\n _wlc_tmp = ctypes.cast(wlc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wlc_ is not None:\n _wlc_copyarray = True\n _wlc_np_tmp = numpy.zeros(len(wlc_),numpy.dtype(numpy.float64))\n _wlc_np_tmp[:] = wlc_\n assert _wlc_np_tmp.flags.contiguous\n _wlc_tmp = ctypes.cast(_wlc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wlc_copyarray = False\n _wlc_tmp = None\n \n _wuc_minlength = self.getnumcon()\n if self.getnumcon() > 0 and wuc_ is not None and len(wuc_) != self.getnumcon():\n raise ValueError(\"Array argument wuc is not long enough: Is %d, expected %d\" % (len(wuc_),self.getnumcon()))\n if isinstance(wuc_, numpy.ndarray) and wuc_.dtype is numpy.dtype(numpy.float64) and wuc_.flags.contiguous:\n _wuc_copyarray = False\n _wuc_tmp = ctypes.cast(wuc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wuc_ is not None:\n _wuc_copyarray = True\n _wuc_np_tmp = numpy.zeros(len(wuc_),numpy.dtype(numpy.float64))\n _wuc_np_tmp[:] = wuc_\n assert _wuc_np_tmp.flags.contiguous\n _wuc_tmp = ctypes.cast(_wuc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wuc_copyarray = False\n _wuc_tmp = None\n \n _wlx_minlength = self.getnumvar()\n if self.getnumvar() > 0 and wlx_ is not None and len(wlx_) != self.getnumvar():\n raise ValueError(\"Array argument wlx is not long enough: Is %d, expected %d\" % (len(wlx_),self.getnumvar()))\n if isinstance(wlx_, numpy.ndarray) and wlx_.dtype is numpy.dtype(numpy.float64) and wlx_.flags.contiguous:\n _wlx_copyarray = False\n _wlx_tmp = ctypes.cast(wlx_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wlx_ is not None:\n _wlx_copyarray = True\n _wlx_np_tmp = numpy.zeros(len(wlx_),numpy.dtype(numpy.float64))\n _wlx_np_tmp[:] = wlx_\n assert _wlx_np_tmp.flags.contiguous\n _wlx_tmp = ctypes.cast(_wlx_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wlx_copyarray = False\n _wlx_tmp = None\n \n _wux_minlength = self.getnumvar()\n if self.getnumvar() > 0 and wux_ is not None and len(wux_) != self.getnumvar():\n raise ValueError(\"Array argument wux is not long enough: Is %d, expected %d\" % (len(wux_),self.getnumvar()))\n if isinstance(wux_, numpy.ndarray) and wux_.dtype is numpy.dtype(numpy.float64) and wux_.flags.contiguous:\n _wux_copyarray = False\n _wux_tmp = ctypes.cast(wux_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif wux_ is not None:\n _wux_copyarray = True\n _wux_np_tmp = numpy.zeros(len(wux_),numpy.dtype(numpy.float64))\n _wux_np_tmp[:] = wux_\n assert _wux_np_tmp.flags.contiguous\n _wux_tmp = ctypes.cast(_wux_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _wux_copyarray = False\n _wux_tmp = None\n \n res = __library__.MSK_XX_primalrepair(self.__nativep,_wlc_tmp,_wuc_tmp,_wlx_tmp,_wux_tmp)\n if res != 0:\n _,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)","def vp():\r\n section = document.add_section()\r\n new_width, new_height = section.page_height, section.page_width\r\n section.orientation = WD_ORIENT.LANDSCAPE\r\n section.page_width = 10058400\r\n section.page_height = 7772400\r\n document.add_heading('Virtual Proxy details', 1)\r\n virtualproxy_metrics= ['description', 'prefix', 'authenticationModuleRedirectUri', 'sessionModuleBaseUri', 'loadBalancingModuleBaseUri', 'authenticationMethod', 'headerAuthenticationMode',\r\n 'headerAuthenticationHeaderName', 'headerAuthenticationStaticUserDirectory', 'headerAuthenticationDynamicUserDirectory', 'anonymousAccessMode', 'windowsAuthenticationEnabledDevicePattern',\r\n 'sessionCookieHeaderName', 'sessionCookieDomain', 'additionalResponseHeaders', 'sessionInactivityTimeout', 'extendedSecurityEnvironment', 'websocketCrossOriginWhiteList', 'defaultVirtualProxy',\r\n 'tags','samlMetadataIdP', 'samlHostUri', 'samlEntityId', 'samlAttributeUserId', 'samlAttributeUserDirectory', 'samlAttributeSigningAlgorithm', 'samlAttributeMap', 'magicLinkHostUri',\r\n 'magicLinkFriendlyName','jwtPublicKeyCertificate','jwtAttributeUserDirectory','jwtAttributeMap','jwtAttributeUserId']\r\n \r\n virtualproxynodes = get_qlik_sense.get_virtualproxy()\r\n num_of_virtualproxys = len(virtualproxynodes)\r\n num_of_virtualproxy_metrics = len(virtualproxy_metrics)\r\n table = document.add_table(rows=num_of_virtualproxy_metrics+1, cols=num_of_virtualproxys+1)\r\n table.style = 'Grid Table 1 Light Accent 1'\r\n row = table.rows[0]\r\n row.cells[0].text = 'Metric'\r\n for item in range(0, num_of_virtualproxys):\r\n row.cells[item+1].text = virtualproxynodes[item][29]\r\n for item in range(num_of_virtualproxy_metrics):\r\n row = table.rows[item+1]\r\n row.cells[0].text = str(virtualproxy_metrics[item])\r\n for virtualproxynode in range(num_of_virtualproxys):\r\n row.cells[virtualproxynode+1].text = str(virtualproxynodes[virtualproxynode][item])\r\n\r\n document.add_page_break()","def get_bforce_wm_ws_Gx_surf(self):\n\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w'] \n \n self.Gm1 = np.zeros([Ly])\n self.dGm1_dS = np.zeros([Ly]) \n self.Gt1 = np.zeros([Ly])\n self.dGt1_dS = np.zeros([Ly]) \n self.Bfsfc_bl = np.zeros([Ly])\n self.Av_bl = np.zeros([Ly])\n self.dAv_bl = np.zeros([Ly])\n \n #debugging\n self.wm_surf = np.zeros([Ly])\n self.ws_surf = np.zeros([Ly]) \n\n #---> j-loop\n for j in range(Ly): \n k_w = self.kbl[j] # KBL is \"new bl index after calling find_new_kbl()\n z_bl = z_u_w[j,N] - self.hbls[j]\n zscale = self.hbls[j] \n \n if self.swr_frac[j,k_w-1] > 0:\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\n \n else:\n Bfsfc = self.Bo[j] + self.Bosol[j]\n \n # CALCUALTE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm_surf[j] = wm\n self.ws_surf[j] = ws \n\n if self.LIMIT_UNSTABLE_ONLY:\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\n else:\n f1 = 0\n\n \n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n\n #MOMENTUM \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl[j] = Av_bl\n self.dAv_bl[j] = dAv_bl\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \n\n #TEMPERATURE(BUOYANCY)\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \n\n self.Bfsfc_bl[j] = Bfsfc","def get_w(self):\n raise NotImplementedError","def propose(self):\n\n\n fb = 0.0\n changed_any = False\n\n while not changed_any:\n new = copy(self) ## Now we just copy the whole thing\n\n for w in self.all_words():\n if flip(self.propose_p):\n try:\n xp, xfb = self.get_word(w).propose()\n\n changed_any = True\n new.set_word(w, xp)\n fb += xfb\n\n except ProposalFailedException:\n pass\n\n\n return new, fb","def build_W(points):\n return None","def computeW(self):\n E = np.where(self.v > 0, 1, -1)\n # theshold the connections to only -1,1\n binary_weights = np.where(self.c > 0, 1, self.c)\n binary_weights = np.where(binary_weights < 0, -1, binary_weights)\n W = np.sum(binary_weights * np.dot(E.reshape(-1,1), E.reshape(1,-1))) # W = C * E * E\n self.W = W\n if np.sum(binary_weights) != 0:\n self.W = self.W / np.sum(binary_weights) # W / W*\n return self.W","def vcac_worklfow_request(self):\n logging.info(\"Inside ucsvm_worklfow_request method base class\")\n return None","def get_wordcloud():\n params = request.args\n result = None\n\n def set_result(x):\n nonlocal result # This is ugly, ew, gotta fix this\n result = x\n\n pipeline_zoo.get_full_word_distribution(set_result).feed_data((params, None))\n return jsonify({\n 'word_distribution': result\n })","def get_vector(word, model):\n return model.wv[word]","def new_words_only(base_words, window_words):\n new_words = []\n if base_words:\n for wword in window_words:\n dont_include = False\n for bword in base_words:\n if CharNetRunner._do_words_intersect(wword, bword):\n dont_include = True\n break\n if not dont_include:\n new_words.append(wword)\n else:\n new_words = window_words\n\n return new_words","def search_clues(self):\r\n print(\"\\n************Searching Clues************\\n\")\r\n for word_id in self.words.keys():\r\n if not self.words[word_id].see and not self.words[word_id].wth:\r\n clue = pop_backslash(self.words[word_id].clue)\r\n temp = word_domain(\"allintext:\" + clue +' -crossword',self.words[word_id].length)\r\n temp2 = temp + word_domain(clue +' -crossword',self.words[word_id].length)\r\n domain = temp2 + data_muse(clue, self.words[word_id].length)\r\n unique_list = []\r\n for x in domain: \r\n y = x.upper()\r\n # check if exists in unique_list or not \r\n if y not in unique_list: \r\n unique_list.append(y) \r\n \r\n self.words[word_id].assign_word_domain(unique_list)\r\n print(\"\\nSearch is done...\")","def build_parameters(pobj):\n ViscosityWilke.build_parameters(pobj)","def wps(model, data):\n with msg.loading(f\"Loading model '{model}'...\"):\n nlp = spacy.load(model)\n texts = (eg[\"text\"] for eg in srsly.read_jsonl(data))\n n_docs = 0\n n_words = 0\n start_time = timer()\n for doc in nlp.pipe(texts):\n n_docs += 1\n n_words += len(doc)\n end_time = timer()\n wps = int(n_words / (end_time - start_time))\n result = [\n (\"Docs\", f\"{n_docs:,}\"),\n (\"Words\", f\"{n_words:,}\"),\n (\"Words/s\", f\"{wps:,}\"),\n ]\n msg.table(result, widths=(7, 12), aligns=(\"l\", \"r\"))","def get_doc_prov(j, gcis_url, refList):\n gcis_ns = \"https://gcis-search-stage.jpl.net:3000/gcis.owl#\"\n doc = ProvEsDocument()\n bndl = None\n \n#to get people attributed to, you need to grab article -> jornal_identifier -> look up in references\n# for ref in refList:\n# if ref['child_publication'] == j['uri']:\n \n\n\n doc_attrs = [\n (\"prov:type\", 'gcis:Article'),\n (\"prov:label\", j['title']),\n (\"prov:location\", j['uri']),\n #(\"prov:wasAttributedTo\", j['']),\n ]\n doc.entity('bibo:%s' % j['identifier'], doc_attrs)\n\n prov_json = json.loads(doc.serialize())\n\n return prov_json","def isMWS_WD(primary=None, gaia=None, galb=None, astrometricexcessnoise=None,\n pmra=None, pmdec=None, parallax=None, parallaxovererror=None,\n photbprpexcessfactor=None, astrometricsigma5dmax=None,\n gaiagmag=None, gaiabmag=None, gaiarmag=None, paramssolved=None):\n if primary is None:\n primary = np.ones_like(gaia, dtype='?')\n mws = primary.copy()\n\n # ADM do not target any objects for which entries are NaN\n # ADM and turn off the NaNs for those entries.\n if photbprpexcessfactor is not None:\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\n np.isnan(parallax) | np.isnan(photbprpexcessfactor))\n else:\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\n np.isnan(parallax))\n w = np.where(nans)[0]\n if len(w) > 0:\n parallax, gaiagmag = parallax.copy(), gaiagmag.copy()\n gaiabmag, gaiarmag = gaiabmag.copy(), gaiarmag.copy()\n if photbprpexcessfactor is not None:\n photbprpexcessfactor = photbprpexcessfactor.copy()\n # ADM safe to make these zero regardless of cuts as...\n photbprpexcessfactor[w] = 0.\n parallax[w] = 0.\n gaiagmag[w], gaiabmag[w], gaiarmag[w] = 0., 0., 0.\n # ADM ...we'll turn off all bits here.\n mws &= ~nans\n# log.info('{}/{} NaNs in file...t = {:.1f}s'\n# .format(len(w), len(mws), time()-start))\n\n # ADM apply the selection for all MWS-WD targets\n # ADM must be a Legacy Surveys object that matches a Gaia source\n mws &= gaia\n\n # ADM and all astrometric parameters are measured.\n mws &= paramssolved == 31\n\n # ADM Gaia G mag of less than 20\n mws &= gaiagmag < 20.\n\n # ADM Galactic b at least 20o from the plane\n mws &= np.abs(galb) > 20.\n\n # ADM gentle cut on parallax significance\n mws &= parallaxovererror > 1.\n\n # ADM Color/absolute magnitude cuts of (defining the WD cooling sequence):\n # ADM Gabs > 5\n # ADM Gabs > 5.93 + 5.047(Bp-Rp)\n # ADM Gabs > 6(Bp-Rp)3 - 21.77(Bp-Rp)2 + 27.91(Bp-Rp) + 0.897\n # ADM Bp-Rp < 1.7\n Gabs = gaiagmag+5.*np.log10(parallax.clip(1e-16))-10.\n br = gaiabmag - gaiarmag\n mws &= Gabs > 5.\n mws &= Gabs > 5.93 + 5.047*br\n mws &= Gabs > 6*br*br*br - 21.77*br*br + 27.91*br + 0.897\n mws &= br < 1.7\n\n # ADM Finite proper motion to reject quasars\n # ADM Inexplicably I'm getting a Runtimewarning here for\n # ADM a few values in the sqrt, so I'm catching it\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n pm = np.sqrt(pmra**2. + pmdec**2.)\n mws &= pm > 2.\n\n # ADM As of DR7, photbprpexcessfactor and astrometricsigma5dmax are not in the\n # ADM imaging catalogs. Until they are, ignore these cuts\n if photbprpexcessfactor is not None:\n # ADM remove problem objects, which often have bad astrometry\n mws &= photbprpexcessfactor < 1.7 + 0.06*br*br\n\n if astrometricsigma5dmax is not None:\n # ADM Reject white dwarfs that have really poor astrometry while\n # ADM retaining white dwarfs that only have relatively poor astrometry\n mws &= ((astrometricsigma5dmax < 1.5) |\n ((astrometricexcessnoise < 1.) & (parallaxovererror > 4.) & (pm > 10.)))\n\n return mws","def test_visualize_wfe_budget():\n nrc = webbpsf.NIRCam()\n nrc.visualize_wfe_budget()","def evaluate_design(self): # to update the pr object","def getVWFile(tsvFile, vwFile, dataIndex, dictionary, tfidf_model, train=True):\r\n start = datetime.now()\r\n \r\n # extract all the index\r\n catIndex = dataIndex[\"catIndex\"]\r\n subCatIndex = dataIndex[\"subCatIndex\"]\r\n attrsKeyIndex = dataIndex[\"attrsKeyIndex\"]\r\n attrsValIndex = dataIndex[\"attrsValIndex\"]\r\n wordIndex = dataIndex[\"wordIndex\"]\r\n \r\n with open(vwFile, \"wb\") as vwWriter:\r\n with open(tsvFile, \"rb\") as tsvReader:\r\n itemReader = DictReader(tsvReader, delimiter='\\t', quotechar='\"')\r\n for i, item in enumerate(itemReader):\r\n item = {featureName:featureValue.decode('utf-8') \\\r\n for featureName,featureValue in item.items() \\\r\n if featureValue is not None}\r\n\r\n # get header\r\n itemid = int(item[\"itemid\"])\r\n label = int(item[\"is_blocked\"]) if train else 1\r\n header = \"%s '%s \" % (int(2*label - 1), itemid)\r\n \r\n # category\r\n categoryFeat = \"|C %s \" % catIndex[ item[\"category\"] ]\r\n \r\n # subcategory\r\n subcategoryFeat = \"|SC %s \" % subCatIndex[ item[\"subcategory\"] ]\r\n \r\n # title\r\n title = [ str(wordIndex[w]) for w in getWords(item[\"title\"]) ]\r\n # first-gram\r\n title_start = title[0] if len(title)>0 else \"0\"\r\n # end-gram\r\n title_end = title[-1] if len(title)>0 else \"0\"\r\n # naming is a pain for me\r\n titleFeat = \"|T %s |bT %s |cT %s \" % (\" \".join(title), title_start, title_end)\r\n titleStatsFeat = \"|t %s \" % getTextStatsFeat(item[\"title\"])\r\n \r\n # description\r\n description = [ str(wordIndex[w]) for w in getWords(item[\"description\"]) ]\r\n # first-gram\r\n description_start = description[0] if len(description)>0 else \"0\"\r\n # end-gram\r\n description_end = description[-1] if len(description)>0 else \"0\"\r\n descriptionFeat = \"|D %s |fD %s |gD %s \" % (\" \".join(description), description_start, description_end)\r\n descriptionStatsFeat = \"|d %s \" % getTextStatsFeat(item[\"description\"])\r\n tfidf_feat1 = getTfidfFeat(getUnigram(description), dictionary[1], tfidf_model[1])\r\n # 2gram tfidf seem to harm the performance, you are save to drop it here\r\n tfidf_feat2 = getTfidfFeat(getBigram(description, \"_\"), dictionary[2], tfidf_model[2])\r\n descriptionFeat += \"|iD %s |jD %s \" % (tfidf_feat1, tfidf_feat2)\r\n \r\n # attrs\r\n attrsFeat = \"\"\r\n countAttrs = 0\r\n if \"attrs\" in item:\r\n attrsDict = getAttrsDict(item[\"attrs\"])\r\n #print attrs\r\n for k,v in list(attrsDict.items()):\r\n countAttrs += 1\r\n attrsFeat += \"|A%s %s \" % (attrsKeyIndex[k], attrsValIndex[v])\r\n attrsFeat += \"|a \"\r\n for k,v in list(attrsDict.items()):\r\n attrsFeat += \"%s \" % (attrsKeyIndex[k]) \r\n if len(attrsFeat) == 0:\r\n attrsFeat = \"|NA 1 \"\r\n attrsFeat += \"|hAC %s \" % countAttrs\r\n \r\n # price\r\n priceFeat = \"|P %s \" % item[\"price\"] \r\n # phones_cnt\r\n phonesCntFeat = \"|p %s \" % item[\"phones_cnt\"]\r\n # emails_cnt\r\n emailsCntFeat = \"|e %s \" % item[\"emails_cnt\"]\r\n # urls_cnt\r\n urlsCntFeat = \"|u %s \" % item[\"urls_cnt\"]\r\n \r\n # output\r\n vwLine = header \\\r\n + categoryFeat \\\r\n + subcategoryFeat \\\r\n + titleFeat \\\r\n + titleStatsFeat \\\r\n + descriptionFeat \\\r\n + descriptionStatsFeat \\\r\n + attrsFeat \\\r\n + priceFeat \\\r\n + phonesCntFeat \\\r\n + emailsCntFeat \\\r\n + urlsCntFeat[:-1] + \"\\n\"\r\n vwWriter.write( vwLine )\r\n \r\n # report progress\r\n if (i+1)%10000 == 0:\r\n print(( \"\\n%s\\t%s\"%((i+1),str(datetime.now() - start)) ))\r\n print(( \"Sample output:\\n%s\" % vwLine ))","def check_wf(self,wf):\n pass","def geocube():","def has_wcs(self):\n return self.wcs is not None","def plotrgcloud(self):\n print self.kpunten\n for i in range(len(self.kpunten[0])):\n self.writetext('sen ='+ self.kpunten[0][i][0], (0.65,0.85), axnum = 0, hor = None ,ver = None , rot = None ,fs =14 , transform = self.fig.axes[0].transAxes)\n if i == len(self.kpunten[0]) -1 :\n end = None\n else:\n end = self.kpunten[0][i+1][1] + 1\n print end\n self.plotrgwrap( self.rgindex,2*self.reader.npair+self.rgindex,'real part of rgvars (a.u)' , 'imaginary part of rgvars (a.u.)', tit ='RG vars g = %f all states'%(self.chardata) , begin = self.kpunten[0][i][1] , stop = end , name = 'cpcloud'+ self.kpunten[0][i][0] , filenum = 0)","def newWS(self, y):\n keys=np.array(self.ImageSolution.keys())\n try:\n i=abs(keys-y).argmin()\n ws=self.ImageSolution[keys[i]]\n nws=WavelengthSolution.WavelengthSolution(ws.x_arr,ws.w_arr, order=ws.order, function=ws.function)\n nws.fit()\n return nws\n except :\n return self.ws","def calc_wvf(pedestrian, key, face, mesh_area,radius): \n normal = envuo.py3dmodel.construct.make_vector((0,0,0),envuo.py3dmodel.calculate.face_normal(face))\n surf2ped = envuo.py3dmodel.construct.make_vector(key,pedestrian)\n sa_ped = 4.0*np.pi*radius**2\n theta = normal.Angle(surf2ped)\n h = surf2ped.Magnitude()/radius \n phi = np.arctan(1/h)\n threshold = np.pi/2.0 - phi\n\n if abs(h*np.cos(theta)) > 1:\n F = abs(np.cos(theta))/h**2; \n else:\n x = np.sqrt(h**2-1)/np.tan(theta) #np.sqrt(h**2-1)\n y = np.sqrt(1-x**2) #-x/np.tan(theta) #\n F = (np.pi - abs(np.cos(x)) - x*y*np.tan(theta)**2)*abs(np.cos(theta))/(np.pi*h**2) + np.arctan(y*abs(np.cos(theta))/x)/np.pi; \n print pedestrian,' passes threshold'\n return mesh_area*F/sa_ped","def compute_RS(W):\n return None","def _vSWVT(self):\r\n\r\n logStr = \"{0:s}.{1:s}: \".format(self.__class__.__name__, sys._getframe().f_code.co_name)\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'Start.')) \r\n \r\n try: \r\n vSWVT = None\r\n vSWVT=pd.merge(self.dataFrames['SWVT'],self.dataFrames['SWVT_ROWT'],left_on='pk',right_on='fk')\r\n vSWVT['ZEIT']=pd.to_numeric(vSWVT['ZEIT']) \r\n vSWVT['W']=pd.to_numeric(vSWVT['W']) \r\n vSWVT['ZEIT_RANG']=vSWVT.groupby(['pk_x'])['ZEIT'].rank(ascending=True)\r\n #\r\n vSWVT_g=vSWVT.groupby(['pk_x'], as_index=False).agg({'W':[np.min,np.max]})\r\n vSWVT_g.columns= [tup[0]+tup[1] for tup in zip(vSWVT_g.columns.get_level_values(0),vSWVT_g.columns.get_level_values(1))]\r\n vSWVT_g.rename(columns={'Wamin':'W_min','Wamax':'W_max'},inplace=True)\r\n #\r\n vSWVT=pd.merge(vSWVT,vSWVT_g,left_on='pk_x',right_on='pk_x')\r\n #\r\n vSWVT=vSWVT[vSWVT['ZEIT_RANG']==1]\r\n #\r\n vSWVT=vSWVT[['NAME','BESCHREIBUNG','INTPOL','ZEITOPTION','W','W_min','W_max','pk_x']]\r\n #\r\n vSWVT.rename(columns={'pk_x':'pk'},inplace=True)\r\n \r\n except Exception as e:\r\n logStrFinal=\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\r\n logger.error(logStrFinal) \r\n raise XmError(logStrFinal) \r\n finally:\r\n logger.debug(\"{0:s}{1:s}\".format(logStr,'_Done.'))\r\n return vSWVT","def test_slpi_cwro(self):\r\n\t\twith open(\"test_slpi_cwro.txt\", \"w\") as test_slpi_cwro_output:\r\n\t\t\tsys.stdout = test_slpi_cwro_output # Redirect print in censor to temporary output file\r\n\t\t\t# Appropriate censor function call\r\n\t\t\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=1, censor_words_one_pass=True)\r\n\t\twith open(\"test_slpi_cwro.txt\", \"r\") as test_slpi_cwro_output:\r\n\t\t\twhile True:\r\n\t\t\t\t# Assert every output line in file matches the expected output\r\n\t\t\t\tline_output = test_slpi_cwro_output.readline()\r\n\t\t\t\tline_correct = cc_test_prose.readline()\r\n\t\t\t\tself.assertEqual(line_output, line_correct)\r\n\t\t\t\tif line_correct == '': # Stop reading expected output at eof\r\n\t\t\t\t\tbreak\r\n\t\tcc_test_prose.seek(0) # Reset read head in expected output file\r\n\t\tsys.stdout = sys.__stdout__ # Reset stdout redirection\r\n\t\tos.remove(\"test_slpi_cwro.txt\") # Delete temporary output file if test is successful\r","def collecte_docs(self, chercheur, overwrite=False): # self,\n init = overwrite # If True, data persistence is lost when references are updated\n docs = hal.find_publications(chercheur[\"halId_s\"], \"authIdHal_s\")\n\n progress_recorder = ProgressRecorder(self)\n progress_recorder.set_progress(0, len(docs), description=\"récupération des données HAL\")\n # Insert documents collection\n for num, doc in enumerate(docs):\n doc[\"country_colaboration\"] = location_docs.generate_countrys_fields(doc)\n doc = doi_enrichissement.docs_enrichissement_doi(doc)\n if \"fr_abstract_s\" in doc.keys():\n if isinstance(doc[\"fr_abstract_s\"], list):\n doc[\"fr_abstract_s\"] = \"/n\".join(doc[\"fr_abstract_s\"])\n if len(doc[\"fr_abstract_s\"]) > 100:\n doc[\"fr_entites\"] = keyword_enrichissement.return_entities(\n doc[\"fr_abstract_s\"], \"fr\"\n )\n doc[\"fr_teeft_keywords\"] = keyword_enrichissement.keyword_from_teeft(\n doc[\"fr_abstract_s\"], \"fr\"\n )\n if \"en_abstract_s\" in doc.keys():\n if isinstance(doc[\"en_abstract_s\"], list):\n doc[\"en_abstract_s\"] = \"/n\".join(doc[\"en_abstract_s\"])\n if len(doc[\"en_abstract_s\"]) > 100:\n doc[\"en_entites\"] = keyword_enrichissement.return_entities(\n doc[\"en_abstract_s\"], \"en\"\n )\n doc[\"en_teeft_keywords\"] = keyword_enrichissement.keyword_from_teeft(\n doc[\"en_abstract_s\"], \"en\"\n )\n\n doc[\"_id\"] = doc[\"docid\"]\n doc[\"validated\"] = True\n\n doc[\"harvested_from\"] = \"researcher\"\n\n doc[\"harvested_from_ids\"] = []\n doc[\"harvested_from_label\"] = []\n\n #\n #\n # print(doc[\"authorship\"], doc ['authLastName_s'])\n\n if len(doc[\"authIdHal_s\"]) != len(doc[\"authLastName_s\"]):\n # print (\"elastichal.py : test d'autorat no good\")\n # test sur le nom complet...\n nom = [\n truc\n for truc in doc[\"authLastName_s\"]\n if chercheur[\"lastName\"].lower() in truc.lower()\n ] # pour les récemment mariés qui auraient un nom composé...\n # Après si 'lun des co-auteur porte le même nom...\n if len(nom) > 0:\n nom = nom[0].title()\n try:\n if doc[\"authLastName_s\"].index(nom) == 0: # premier\n doc[\"authorship\"] = [\n {\"authorship\": \"firstAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n elif (\n doc[\"authLastName_s\"].index(nom) == len(doc[\"authLastName_s\"]) - 1\n ): # dernier\n doc[\"authorship\"] = [\n {\"authorship\": \"lastAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n except ValueError:\n doc[\"authorship\"] = []\n else:\n doc[\"authorship\"] = []\n elif chercheur[\"halId_s\"] in doc[\"authIdHal_s\"]:\n if doc[\"authIdHal_s\"].index(chercheur[\"halId_s\"]) == 0:\n doc[\"authorship\"] = [\n {\"authorship\": \"firstAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n elif (\n doc[\"authIdHal_s\"].index(chercheur[\"halId_s\"]) == len(doc[\"authIdHal_s\"]) - 1\n ): # dernier\n doc[\"authorship\"] = [\n {\"authorship\": \"lastAuthor\", \"authIdHal_s\": chercheur[\"halId_s\"]}\n ]\n else:\n doc[\"authorship\"] = []\n else:\n doc[\"authorship\"] = []\n\n doc[\"harvested_from_ids\"].append(chercheur[\"halId_s\"])\n\n # historique d'appartenance du docId\n # pour attribuer les bons docs aux chercheurs\n # harvet_history.append({'docid': doc['docid'], 'from': row['halId_s']})\n #\n # for h in harvet_history:\n # if h['docid'] == doc['docid']:\n # if h['from'] not in doc[\"harvested_from_ids\"]:\n # doc[\"harvested_from_ids\"].append(h['from'])\n\n doc[\"records\"] = []\n\n doc[\"MDS\"] = utils.calculate_mds(doc)\n\n try:\n should_be_open = utils.should_be_open(doc)\n if should_be_open == 1:\n doc[\"should_be_open\"] = True\n if should_be_open == -1:\n doc[\"should_be_open\"] = False\n\n if should_be_open == 1 or should_be_open == 2:\n doc[\"isOaExtra\"] = True\n elif should_be_open == -1:\n doc[\"isOaExtra\"] = False\n except IndexError:\n print(\"publicationDate_tdate error ?\")\n doc[\"Created\"] = datetime.datetime.now().isoformat()\n\n if not init: # récupération de l'existant pour ne pas écraser\n field = \"_id\"\n doc_param = esActions.scope_p(field, doc[\"_id\"])\n\n if not es.indices.exists(\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\"\n ): # -researchers\" + row[\"ldapId\"] + \"-documents\n print(\"exception \", chercheur[\"labHalId\"], chercheur[\"ldapId\"])\n\n res = es.search(\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\",\n body=doc_param,\n ) # -researchers\" + row[\"ldapId\"] + \"-documents\n\n if len(res[\"hits\"][\"hits\"]) > 0:\n doc[\"validated\"] = res[\"hits\"][\"hits\"][0][\"_source\"][\"validated\"]\n if \"authorship\" in res[\"hits\"][\"hits\"][0][\"_source\"]:\n doc[\"authorship\"] = res[\"hits\"][\"hits\"][0][\"_source\"][\"authorship\"]\n\n if (\n res[\"hits\"][\"hits\"][0][\"_source\"][\"modifiedDate_tdate\"]\n != doc[\"modifiedDate_tdate\"]\n ):\n doc[\"records\"].append(\n {\n \"beforeModifiedDate_tdate\": doc[\"modifiedDate_tdate\"],\n \"MDS\": res[\"hits\"][\"hits\"][0][\"_source\"][\"MDS\"],\n }\n )\n\n else:\n doc[\"validated\"] = True\n progress_recorder.set_progress(num, len(docs), description=\"(récolte)\")\n progress_recorder.set_progress(num, len(docs), description=\"(indexation)\")\n helpers.bulk(\n es,\n docs,\n index=chercheur[\"structSirene\"]\n + \"-\"\n + chercheur[\"labHalId\"]\n + \"-researchers-\"\n + chercheur[\"ldapId\"]\n + \"-documents\",\n refresh=\"wait_for\",\n )\n\n return chercheur # au cas où","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',\n verbose=False))\n # No NaNs are supposed to be in the output.\n self.assertEqual(np.isnan(wv).any(), False)\n rms1 = rms(rec['wv_250_500_25'], wv[250:500:25])\n rms2 = rms(rec['wv_750_1000_25'], wv[750:1000:25])\n self.assertEqual(True, rms1 < 1e-6)\n self.assertEqual(True, rms2 < 1e-6)","def exposedSurf(self):\n if self.precision:\n h = self.evaluations.exposedWing.edges[1].point1.x # height of trapezoid\n B = self.chordRootW # major base of trapezoid\n b = self.evaluations.chordIntersected.edges[1].length # minor base of trapezoid\n internalS = 2 * (0.5 * (b + B) * h) # wing surface internal at fuselage\n return self.surfaceW - internalS\n else:\n return self.surfaceW - self.fuselageDiameter * self.cMACW # first guess for a faster evaluation","def init_ngrams(self):\n self.wv.ngrams = {}\n all_ngrams = []\n self.wv.syn0 = np.zeros((len(self.wv.vocab), self.vector_size), dtype=REAL)\n\n for w, vocab in self.wv.vocab.items():\n all_ngrams += compute_ngrams(w, self.wv.min_n, self.wv.max_n)\n self.wv.syn0[vocab.index] += np.array(self.wv.syn0_ngrams[vocab.index])\n\n all_ngrams = set(all_ngrams)\n self.num_ngram_vectors = len(all_ngrams)\n ngram_indices = []\n for i, ngram in enumerate(all_ngrams):\n ngram_hash = ft_hash(ngram)\n ngram_indices.append(len(self.wv.vocab) + ngram_hash % self.bucket)\n self.wv.ngrams[ngram] = i\n self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)\n\n ngram_weights = self.wv.syn0_ngrams\n\n logger.info(\n \"loading weights for %s words for fastText model from %s\",\n len(self.wv.vocab), self.file_name\n )\n\n for w, vocab in self.wv.vocab.items():\n word_ngrams = compute_ngrams(w, self.wv.min_n, self.wv.max_n)\n for word_ngram in word_ngrams:\n self.wv.syn0[vocab.index] += np.array(ngram_weights[self.wv.ngrams[word_ngram]])\n\n self.wv.syn0[vocab.index] /= (len(word_ngrams) + 1)\n logger.info(\n \"loaded %s weight matrix for fastText model from %s\",\n self.wv.syn0.shape, self.file_name\n )","def stop_word(w): # local feature\n return (w in swl)","def v(w,s):\n return w","def build_vocab(self, corpus):\n if self.vocabulary_counts != None:\n logger.debug(\"building vocabulary from provided frequency map\")\n vocab = self.vocabulary_counts\n else:\n logger.debug(\"default vocabulary building\")\n super(Skipgram, self).build_vocab(corpus)\n return\n\n # assign a unique index to each word\n self.vocab, self.index2word = {}, []\n\n for word, count in vocab.iteritems():\n v = Vocab()\n v.count = count\n if v.count >= self.min_count:\n v.index = len(self.vocab)\n self.index2word.append(word)\n self.vocab[word] = v\n\n logger.debug(\"total %i word types after removing those with count<%s\" % (len(self.vocab), self.min_count))\n\n if self.hs:\n # add info about each word's Huffman encoding\n self.create_binary_tree()\n if self.negative:\n # build the table for drawing random words (for negative sampling)\n self.make_table()\n # precalculate downsampling thresholds\n self.precalc_sampling()\n self.reset_weights()","def compare_wavs_length(c_wv, s_wv):\n\n # If the style wav is shorter than the content wav, exit in error\n if s_wv.shape[0] < c_wv.shape[0]:\n raise WavError(\"The style wav must be as long or longer than the content wav\")\n\n # If the style wav is longer, truncate it to match the content length\n elif s_wv.shape[0] > c_wv.shape[0]:\n print(\"Truncating style wav to match content wav length\")\n s_wv = np.copy(s_wv[:c_wv.shape[0],:])\n\n return s_wv","def calc_doc_ret_MAP():\n \n# docs_norm_scores_dicts_path = linux_base_path+\"/docs_norm_scores_dicts\"\n claim_rel_docno_dict = read_pickle(\"claim_rel_docno_dict\") #key is clm, value is a set of the relevant docno\n# nDCG_MAP_res = base_path +\"\\\\nDCG_MAP_res\\\\\"\n# docs_norms_path = base_path+\"\\\\docs_norm_scores_dicts\\\\\"\n docs_norms_path = linux_base_path+\"/docs_norm_scores_dicts/\"\n nDCG_MAP_res = linux_base_path +\"/nDCG_MAP_res/\"\n \n AP_cut_off = 1000\n k_val = 100\n p = 10\n log = open(\"calc_doc_avg_nDCG_MAP_log_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),\"wb\")\n res_file = open(nDCG_MAP_res+\"doc_ret_nDCG_MAP_res_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),\"wb\")\n# each_params_AVGnDCG_MAP_dict = {} #key is alpha,beta,k_docs,lambda and val is the avg nDCG and MAP across all claims together\n each_params_MAP_dict = {}\n# NDCG_AP_all_claims_all_param_values = {}\n AP_all_claims_all_param_values = {}\n best_avg_nDCG = 0\n best_MAP = 0 #across all claims in a given configuration, find the max measures\n \n# docs_norms_path = base_path+\"\\\\docs_norm_scores_dicts\\\\\"\n claims_dict = read_pickle(\"claim_dict\")\n #count the number of sentences that were retrived that are in the true data....sum for each claim, then average.\n \n \n for alpha in range(0,11,1): #change just for test!\n for beta in range(0,10,1):\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\n NDCG_all_claims= {} #key is a claim, value is the nDCG\n AP_all_claims= {} \n AP_cut_off = 1000\n curr_filename = docs_norms_path+\"clm_key_ranked_list_of_docs_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)\n clm_key_ranked_list_of_docs_baseline = read_pickle(curr_filename) #key is qID and docid\n #need to turn it to a list of docs\n for clm in claim_list:\n try:\n# nDCG_score = utils_linux.calc_doc_emp_NDCG(curr_source,str(clm),clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]],p)\n# NDCG_all_claims[clm] = nDCG_score\n AP_score = utils_linux.calc_doc_AP_relevance(AP_cut_off,curr_source,clm,clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]])\n AP_all_claims[clm] = AP_score\n AP_all_claims_all_param_values[clm,alpha_f,beta_f,k_val] = AP_score\n except Exception as err: \n log.write('problem in calculations: in source: '+ curr_source+' in clm '+ claims_dict[str(clm)]+\" alpha:\"+str(alpha_f)+ \"beta:\"+str(beta_f)+\" \\n\" ) \n for arg in err.args:\n log.write(arg+\" \") \n log.write(\"\\n\") \n# average_NDCG = float(float(sum(NDCG_all_claims.values()))/float(len(NDCG_all_claims))) #across all claims...\n# if average_NDCG > best_avg_nDCG:\n# best_avg_nDCG = average_NDCG\n# best_avg_nDCG_configuration = (alpha_f,beta_f,k_val)\n MAP = float(float(sum(AP_all_claims.values()))/float(len(AP_all_claims)))\n if MAP > best_MAP:\n best_MAP = MAP\n best_MAP_configuration = (alpha_f,beta_f,k_val)\n each_params_MAP_dict[alpha_f,beta_f,k_val] = MAP\n utils_linux.save_pickle(nDCG_MAP_res+\"doc_ret_NDCG_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"_at_\"+str(p),NDCG_all_claims)\n utils_linux.save_pickle(nDCG_MAP_res+\"doc_ret_AP_all_claims_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val),AP_all_claims)\n# res_file.write(\"alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"|\"+\"AnDCG_\"+str(average_NDCG)+\"_MAP_\"+str(MAP)+\"\\n\")\n res_file.write(\"alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"|_MAP_\"+str(MAP)+\"\\n\")\n save_pickle(nDCG_MAP_res+\"doc_ret_NDCG_AP_all_claims_all_param_values_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),AP_all_claims_all_param_values)\n save_pickle(nDCG_MAP_res+\"doc_ret_each_params_AVGnDCG_MAP_dict_k_top_docs_\"+str(k_val)+\"_at_\"+str(p),each_params_MAP_dict)\n# best_row = \"best_avg_nDCG|\"+str(best_avg_nDCG)+\"|best_avg_nDCG_configuration|\"+str(best_avg_nDCG_configuration[0])+\",\"+str(best_avg_nDCG_configuration[1])+\",\"+str(best_avg_nDCG_configuration[3])+\",\"+str(best_avg_nDCG_configuration[2])+\"|\"\n best_row = \"best_MAP|\" +str(best_MAP)+\"|best_MAP_configuration|\"+str(best_MAP_configuration[0])+\",\"+str(best_MAP_configuration[1])+\",\"+str(best_MAP_configuration[2])\n res_file.write(best_row)\n res_file.close()\n log.close()","def documento():\r\n\tpass","def qwf(self, vw, ev, gp, psi_l, lai, dt):\n\t\t#if the amount of water in storage is less than amount that will be absorbed by plant in timestep dt, then what's left will be absorbed \n\t qw = (self.gwf(self.psi_wf(self.vw,self.d1, self.d1, self.ns, self.tl), self.H, self.J)*(self.psi_wf(self.vw, self.d1, self.d1, self.ns, self.tl) - (ev*(1. - self.F_CAP))/(lai*gp) - psi_l)*lai)\n\t if self.vw == 0:\n\t return 0.\n\t elif self.vw*10**6 <= qw*dt:\n\t return (self.vw*10**6/dt)\n\t else:\n\t return qw","def _compute_export_in_woo(self):\n for rec in self:\n rec.ks_export_in_woo = bool(rec.ks_woo_id)","def test_continue_build() -> None:\n tknzr = WsTknzr(is_uncased=True, max_vocab=-1, min_count=0)\n tknzr.build_vocab(['a'])\n tknzr.build_vocab(['b'])\n tknzr.build_vocab(['c'])\n assert tknzr.tk2id == {\n BOS_TK: BOS_TKID,\n EOS_TK: EOS_TKID,\n PAD_TK: PAD_TKID,\n UNK_TK: UNK_TKID,\n 'a': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 1,\n 'b': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 2,\n 'c': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 3,\n }","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def zapisi_pot(pot):","def evaluate():\n global dictionary, wv\n count = 0\n # To save the scores by distance and similarity\n scores = np.zeros(6)\n similar = np.zeros(6)\n itr = len(dictionary)\n logging.info('running evaluation for {0} samples'.format(itr))\n for key in dictionary:\n progress = (count / itr) * 100\n d = dictionary[key].split('resource/')\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\n try:\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\n dtype=np.float32)\n except KeyError:\n itr -= 1\n continue\n if np.any(np.isnan(r)):\n itr -= 1\n continue\n else:\n if r.ndim == 2:\n try:\n # Mean of vector containing all word vectors\n # obtained from abstract.\n r = r.mean(axis=0).reshape(1, -1)\n \n # Obtain the vectors for the entity\n mean_vec = mean_encoder(dictionary[key])\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\n mean_dist_vec = distance_encoder(dictionary[key])\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\n title_vec = title_mean(key)\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\n abstract_vec = abstract_encoder(key)\n abstract_vec = abstract_vec.reshape(1, -1)\n abstract_vec = abstract_vec / norm(abstract_vec)\n random_vec = np.random.randn(100).reshape(1, -1)\n zero_vec = np.zeros(100).reshape(1, -1)\n \n # Score the entity vectors\n scores[0] += norm(r - mean_vec)\n scores[1] += norm(r - mean_dist_vec)\n scores[2] += norm(r - title_vec)\n scores[3] += norm(r - abstract_vec)\n scores[4] += norm(r - random_vec)\n scores[5] += norm(r - zero_vec)\n similar[0] += cosine_similarity(r, mean_vec)\n similar[1] += cosine_similarity(r, mean_dist_vec)\n similar[2] += cosine_similarity(r, title_vec)\n similar[3] += cosine_similarity(r, abstract_vec)\n similar[4] += cosine_similarity(r, random_vec)\n similar[5] += cosine_similarity(r, zero_vec)\n count += 1\n print(count, end='\\r')\n except (ValueError, KeyError) as _:\n itr -= 1\n continue\n else:\n itr -= 1\n continue\n # Normalize the scores to get a better\n # comparison against the baselines.\n scores = scores / norm(scores)\n similar = similar / norm(similar)\n print_summary(scores, similar)","def _derW(self, w, x, y, z):\n if _isscalar(w):\n w_pos = max(min(self.wSearchFunc(self.w_list, w), self.w_n - 1), 1)\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\n else:\n w_pos = self.wSearchFunc(self.w_list, w)\n w_pos[w_pos < 1] = 1\n w_pos[w_pos > self.w_n - 1] = self.w_n - 1\n x_pos = self.xSearchFunc(self.x_list, x)\n x_pos[x_pos < 1] = 1\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\n y_pos = self.ySearchFunc(self.y_list, y)\n y_pos[y_pos < 1] = 1\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n z_pos = self.zSearchFunc(self.z_list, z)\n z_pos[z_pos < 1] = 1\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\n i = w_pos # for convenience\n j = x_pos\n k = y_pos\n l = z_pos\n beta = (x - self.x_list[j - 1]) / (self.x_list[j] - self.x_list[j - 1])\n gamma = (y - self.y_list[k - 1]) / (self.y_list[k] - self.y_list[k - 1])\n delta = (z - self.z_list[l - 1]) / (self.z_list[l] - self.z_list[l - 1])\n dfdw = (\n (\n (1 - beta)\n * (1 - gamma)\n * (1 - delta)\n * self.f_values[i, j - 1, k - 1, l - 1]\n + (1 - beta) * (1 - gamma) * delta * self.f_values[i, j - 1, k - 1, l]\n + (1 - beta) * gamma * (1 - delta) * self.f_values[i, j - 1, k, l - 1]\n + (1 - beta) * gamma * delta * self.f_values[i, j - 1, k, l]\n + beta * (1 - gamma) * (1 - delta) * self.f_values[i, j, k - 1, l - 1]\n + beta * (1 - gamma) * delta * self.f_values[i, j, k - 1, l]\n + beta * gamma * (1 - delta) * self.f_values[i, j, k, l - 1]\n + beta * gamma * delta * self.f_values[i, j, k, l]\n )\n - (\n (1 - beta)\n * (1 - gamma)\n * (1 - delta)\n * self.f_values[i - 1, j - 1, k - 1, l - 1]\n + (1 - beta)\n * (1 - gamma)\n * delta\n * self.f_values[i - 1, j - 1, k - 1, l]\n + (1 - beta)\n * gamma\n * (1 - delta)\n * self.f_values[i - 1, j - 1, k, l - 1]\n + (1 - beta) * gamma * delta * self.f_values[i - 1, j - 1, k, l]\n + beta\n * (1 - gamma)\n * (1 - delta)\n * self.f_values[i - 1, j, k - 1, l - 1]\n + beta * (1 - gamma) * delta * self.f_values[i - 1, j, k - 1, l]\n + beta * gamma * (1 - delta) * self.f_values[i - 1, j, k, l - 1]\n + beta * gamma * delta * self.f_values[i - 1, j, k, l]\n )\n ) / (self.w_list[i] - self.w_list[i - 1])\n return dfdw","def _get_context_from_gdoc(self, key):\n try:\n content = self.export_xlsx(key)\n data = process_xlsx(content)\n if 'values' in data:\n data = copy_global_values(data)\n return data\n except BadStatusLine:\n # Stale connection, reset API and data\n puts(\"Connection reset, reloading drive API\")\n self.client = get_drive_api()\n return self._get_context_from_gdoc(key)","def test_validate_wc3(self):\r\n assert self.wc2_tree != 0","def vwf(self, vw, ev, gp, psi_l, lai, dt):\n\t return min(vw - self.qwf(self.vw, self.th, self.gp, self.psi_l, self.LAI, dt)*dt/10.**6, self.ZW)","def w(self): # pylint: disable=invalid-name\n return self._w","def processVS(self, model=\"okapi\", l = 0.5):\n self.results[model] = {}\n for query in self.queries:\n res = {}\n for doc in query.docs.values():\n sum_otf = 0.0\n for term in doc.terms:\n if model == \"okapi\":\n sum_otf += self.okapiTF(term.tf, doc.dlen, self.avgdlen)\n if model == \"tfidf\":\n sum_otf += self.tfidf(term.tf, term.df, doc.dlen, self.avgdlen, self.num_docs)\n if model == \"bm25\":\n sum_otf += self.bm25(term.tf, term.df, query.query_tf[term.term], doc.dlen, self.avgdlen, self.num_docs)\n res[doc.id] = sum_otf\n self.results[model][query.id] = res","def computeProportionWings(self):\n self.ws_me_pointsA = []\n self.ws_me_pointsIy = []\n self.ws_me_pointsIz = []\n self.ws_me_pointsJ = []\n for i in range(self.nWings):\n wingIndex = i+1\n wingNnodes = self.settings[\"wing\"+str(wingIndex)][\"FEM\"][\"nodesFEM\"]\n if self.tigl.wingGetSymmetry(i+1) != 0:\n wingNnodes = 2*wingNnodes - 1\n inputMaxA = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"A\"]\n inputMaxIy = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"Iy\"]\n inputMaxIz = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"Iz\"]\n inputMaxJ = self.settings[\"wing\"+str(wingIndex)][\"mechanicalProperties\"][\"J\"]\n inputInterpolationType = self.settings[\"wing\"+str(wingIndex)][\"FEM\"][\"mechanicalInterpolationType\"]\n index = np.argmax(self.ws_me_pointsInitArea[i])\n wingMaxArea = self.ws_me_pointsInitArea[i][index]\n\n if inputInterpolationType == \"constant\":\n exposant = 0\n elif inputInterpolationType == \"linear\":\n exposant = 1\n elif inputInterpolationType == \"quadratic\":\n exposant = 2\n else:\n logger.error(\"Wing mechanical properties distribution is\")\n logger.error(\"wrong. Accepted values are \\\"constant\\\",\")\n logger.error(\"\\\"linear\\\", \\\"quadratic\\\"\")\n sys.exit()\n\n coef = np.empty(wingNnodes)\n self.w_m_pointsA = np.empty(wingNnodes)\n self.w_m_pointsIy = np.empty(wingNnodes)\n self.w_m_pointsIz = np.empty(wingNnodes)\n self.w_m_pointsJ = np.empty(wingNnodes)\n for j in range(wingNnodes):\n coef[j] = self.ws_me_pointsInitArea[i][j]/wingMaxArea\n self.w_m_pointsA[j] = inputMaxA * coef[j]\n self.w_m_pointsIy[j] = inputMaxIy * coef[j]**exposant\n self.w_m_pointsIz[j] = inputMaxIz * coef[j]**exposant\n self.w_m_pointsJ[j] = inputMaxJ * coef[j]**exposant\n self.ws_me_pointsA.append(self.w_m_pointsA)\n self.ws_me_pointsIy.append(self.w_m_pointsIy)\n self.ws_me_pointsIz.append(self.w_m_pointsIz)\n self.ws_me_pointsJ.append(self.w_m_pointsJ)","def unknown(self, w):\n return True","def generate_wordcloud():\r\n # \"\"\"Join list into one string\"\"\"\r\n # unique_string = (\" \").join(prioritized)\r\n # wc = WordCloud(background_color=\"black\", width=2000, height=2000,contour_color=\"black\", max_words=30, relative_scaling=0.5, normalize_plurals=False).generate(unique_string)\r\n\r\n \"\"\"Generate word cloud based on dictionary\"\"\"\r\n wc = WordCloud(background_color=\"black\", width=2000, height=2000, contour_color=\"black\", max_words=30,\r\n relative_scaling=0.5, normalize_plurals=False).generate_from_frequencies(priority_dict)\r\n\r\n fig = plt.figure(figsize=(10, 7))\r\n fig.suptitle(\"Top 30 Most Visited Websites\")\r\n plt.imshow(wc, interpolation=\"bilinear\")\r\n plt.axis(\"on\")\r\n plt.show()","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 w(self):\n return self._w","def filter_w2v_nomenclature(w2vfilename,filter_nomenclature):\n V = set(filter_nomenclature)\n wordlist = []\n veclist = [] \n istream = open(w2vfilename)\n istream.readline() #skips w2v header\n for line in istream:\n fields = line.split()\n word = fields[0]\n if word in V:\n vec = np.array([float(elt) for elt in fields[1:]])\n wordlist.append(word)\n veclist.append(vec)\n istream.close()\n M = np.array(veclist)\n return (wordlist,M)","def check_for_correction(dummy_arg):\n #space_indexes = []\n #new_space_indexes = []\n #punct_dict = {}\n\n # Get current document and attributes for doc\n doc = XSCRIPTCONTEXT.getDocument()\n selection_supplier = doc.getCurrentController()\n indexAccess = selection_supplier.getSelection()\n #count = indexAccess.getCount() # don't really need this right now. Only loop once..\n\n # get cursor to write corrected word highlighted in blue\n text = doc.Text\n vis_cursor = doc.getCurrentController().getViewCursor() # visible cursor in OpenOffice\n nvis_cursor= vis_cursor.getText().createTextCursorByRange(vis_cursor) # not visible cursor place at same place as visible\n \n # set str and txt for use\n highlighted_txt = indexAccess.getByIndex(0)\n highlighted_str = highlighted_txt.getString()\n \n # strip punctuation from string\n punctuation = set(string.punctuation)\n '''\n for letter in highlighted_str:\n if letter == ' ':\n sp_index = highlighted_str.index(letter)\n space_indexes.append(sp_index + len(space_indexes))\n highlighted_str = highlighted_str.replace(letter,'',1)\n \n for index in space_indexes:\n highlighted_str = highlighted_str[:index] + ' ' + highlighted_str[index:]\n\n \n for letter in highlighted_str:\n if letter in punctuation:\n punc_index = highlighted_str.index(letter)\n punct_dict[letter] = punc_index\n highlighted_str = highlighted_str.replace(letter,'',1)\n '''\n highlighted_str = ''.join(ch for ch in highlighted_str if ch not in punctuation) \n highlighted_str_arr = highlighted_str.split()\n\n corrected_sent = highlighted_str # correct sentence to be displayed at end\n\n # check for correction for each word highlighted\n for word in highlighted_str_arr:\n\n if len(highlighted_str) == 0:\n return None\n\n # call make_correction helper function to correct highlighted word\n else:\n correction = make_correction(word)\n \n # make sure new correction word is present\n if correction:\n # get parent window from document\n parentwin = doc.CurrentController.Frame.ContainerWindow\n # make window\n correction_query_str = word + \" => \" + correction # show old word => new word\n prompt = MessageBox(parentwin, correction_query_str, \"Correction:\", MESSAGEBOX, BUTTONS_YES_NO)\n \n # if yes button pressed, replace word\n if prompt == 2:\n # replace wrong word with corrected word\n corrected_sent = corrected_sent.replace(word, correction)\n '''\n for letter in corrected_sent:\n if letter == ' ':\n sp_index = corrected_sent.index(letter)\n new_space_indexes.append(sp_index + len(new_space_indexes))\n corrected_sent = corrected_sent.replace(letter,'',1)\n \n for index in new_space_indexes:\n corrected_sent = corrected_sent[:index] + ' ' + corrected_sent[index:]\n \n \n punc_location = {}\n for key in punct_dict:\n p_index = punct_dict[key]\n for s_index in space_indexes:\n if abs(p_index-s_index) == 1:\n location_index = space_indexes.index(s_index)\n if p_index-s_index > 0:\n punc_location[key] = new_space_indexes[location_index+1]\n else:\n punc_location[key] = new_space_indexes[location_index-1]\n\n\n for key in punc_location:\n index = punc_location[key]\n corrected_sent = key\n #corrected_sent = corrected_sent[:index] + key + corrected_sent[index:]\n ''' \n #highlighted_txt.setString(highlighted_str)\n highlighted_txt.setString(corrected_sent) # replace old word with nothing"],"string":"[\n \"def _compute_wo(self):\\n self.uom_id = self.wo_id.uom_id.id\\n self.final_product_id = self.wo_id.final_product_id.id\\n if not self.supplier_id:\\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\\n else:\\n service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\\n if service_ids:\\n product_supp_rcs = self.env['product.supplierinfo'].search([('partner_id', '=', self.supplier_id.id), ('product_id', 'in', service_ids)])\\n if product_supp_rcs:\\n product_ids = [x.product_id.id for x in product_supp_rcs if x.product_id]\\n else:\\n product_ids = []\\n else:\\n product_ids = [] \\n \\n self.service_ids = product_ids\\n \\n # Permet de savoir si l'OT suivant est de sous-traitance et qu'il y a qu'un seul OT suivant\\n no_direct_fp = True\\n if self.wo_id.next_wo_ids and len(self.wo_id.next_wo_ids) == 1 and self.wo_id.next_wo_ids[0].is_subcontracting and self.wo_id.next_wo_ids[0].consumed_service_ids:\\n no_direct_fp = False\\n \\n self.no_direct_fp = no_direct_fp\",\n \"def convert_pr_wvi_to_string(pr_wvi, nlu_t, nlu_wp_t, wp_to_wh_index, nlu):\\r\\n pr_wv_str_wp = [] # word-piece version\\r\\n pr_wv_str = []\\r\\n for b, pr_wvi1 in enumerate(pr_wvi):\\r\\n pr_wv_str_wp1 = []\\r\\n pr_wv_str1 = []\\r\\n wp_to_wh_index1 = wp_to_wh_index[b]\\r\\n nlu_wp_t1 = nlu_wp_t[b]\\r\\n nlu_t1 = nlu_t[b]\\r\\n\\r\\n for i_wn, pr_wvi11 in enumerate(pr_wvi1):\\r\\n st_idx, ed_idx = pr_wvi11\\r\\n\\r\\n # Ad-hoc modification of ed_idx to deal with wp-tokenization effect.\\r\\n # e.g.) to convert \\\"butler cc (\\\" ->\\\"butler cc (ks)\\\" (dev set 1st question).\\r\\n pr_wv_str_wp11 = nlu_wp_t1[st_idx:ed_idx+1]\\r\\n pr_wv_str_wp1.append(pr_wv_str_wp11)\\r\\n\\r\\n st_wh_idx = wp_to_wh_index1[st_idx]\\r\\n ed_wh_idx = wp_to_wh_index1[ed_idx]\\r\\n pr_wv_str11 = nlu_t1[st_wh_idx:ed_wh_idx+1]\\r\\n\\r\\n pr_wv_str1.append(pr_wv_str11)\\r\\n\\r\\n pr_wv_str_wp.append(pr_wv_str_wp1)\\r\\n pr_wv_str.append(pr_wv_str1)\\r\\n\\r\\n return pr_wv_str, pr_wv_str_wp\",\n \"def unknown(self, w):\\n # WORK HERE!!\",\n \"def _compute_wo(self):\\n self.uom_id = self.wo_id.uom_id.id\\n self.final_product_id = self.wo_id.final_product_id.id\\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\",\n \"def get_wm_ws_Gx_bot(self):\\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \\n z_u_r = self.grid_dict['z_u_r']\\n z_u_w = self.grid_dict['z_u_w']\\n [Ly,N] = self.b.shape\\n #---> j-loop\\n for j in range(Ly): \\n self.kbl[j] = N # initialize search\\n #-> end j-loop\\n\\n #--> k-loop\\n for k in range(N-1,0,-1):\\n k_w = k\\n k_r = k-1\\n # --> j loop \\n for j in range(Ly):\\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\\n self.kbl[j] = k_w\\n\\n #--> end k\\n # --> end j\\n\\n\\n '''\\n Compute nondimenisonal shape function coefficeints Gx() by\\n matching values and vertical derivatives of interior mixing\\n coefficients at hbbl (sigma=1)\\n '''\\n\\n self.Gm1_bot = np.zeros([Ly])\\n self.dGm1_dS_bot = np.zeros([Ly])\\n self.Gt1_bot = np.zeros([Ly])\\n self.dGt1_dS_bot = np.zeros([Ly]) \\n self.Av_bl_bot = np.zeros([Ly])\\n self.dAv_bl_bot = np.zeros([Ly]) \\n self.cff_up_bot = np.zeros([Ly])\\n self.cff_dn_bot = np.zeros([Ly])\\n\\n\\n\\n\\n\\n self.wm_bot = np.zeros([Ly])\\n self.ws_bot = np.zeros([Ly]) \\n\\n # CALCULATE ustar for the bottom based on bototm velocities\\n \\n \\n \\n # CALCULATE r_D\\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \\n u = self.u\\n v_upts = TTTW_func.v2u(self.v)\\n \\n ubar = np.mean(u,axis=1)\\n vbar = np.mean(v_upts,axis=1)\\n\\n # --> j loop\\n for j in range(Ly):\\n # turbulent velocity sclaes with buoyancy effects neglected\\n if self.CD_SWITCH:\\n # DEPTH AVERAGED APPROACH\\n uref = u[j,0]\\n vref = v_upts[j,0]\\n ustar2 = self.C_D * (uref**2 + vref**2)\\n else:\\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\\n wm = self.vonKar * np.sqrt(ustar2)\\n ws = wm\\n\\n self.wm_bot[j] = wm\\n self.ws_bot[j] = ws\\n \\n k_w = self.kbl[j] \\n z_bl = z_u_w[j,0] + self.hbbl[j]\\n\\n if z_bl < z_u_w[j,k_w-1]:\\n k_w = k_w-1\\n\\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl_bot[j] = Av_bl\\n self.dAv_bl_bot[j] = dAv_bl\\n\\n\\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\\n\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])\",\n \"def grounding_words(self, w):\\n story_visual_words = [x for x in self.visual_words if x in self.vocab]\\n visual_word_ids = [self.vocab_ids[x] for x in story_visual_words]\\n visual_similarities = self.sigma_A[self.vocab_ids[w]][visual_word_ids]\\n return sorted(zip(story_visual_words, visual_similarities), key = lambda x : -x[1])\",\n \"def wisdom(search_me, source, pdfurl, userid):\\n ### source needs to be name of data source (\\\"arxiv\\\", \\\"google scholar\\\", \\\"doaj\\\")\\n search_me = search_me.strip()\\n # check if pdfurl has been found before\\n pdf = db_summaries.find_one({\\\"url\\\": pdfurl})\\n if pdf:\\n text = pdf.get('text')\\n summary = pdf.get('summary')\\n topics = pdf.get('topics')\\n # update in db if data is 1 days or older\\n last_updated = datetime.utcnow() - pdf.get(\\\"last_updated\\\")\\n last_updated_diff = last_updated.days\\n if last_updated_diff > 1:\\n search_term = db_search_terms.find_one({\\\"value\\\": search_me.lower()})\\n search_id = search_term.get(\\\"_id\\\")\\n data = {\\\"search_id\\\": search_id,\\n \\\"url\\\": pdfurl, \\\"source\\\": source, \\\"text\\\": text,\\n \\\"summary\\\": summary, \\\"topics\\\": topics, \\\"last_updated\\\": datetime.utcnow()}\\n db_summaries.update({\\\"url\\\": pdfurl}, {\\\"$set\\\": data})\\n else:\\n pass\\n else:\\n text = wisdomaiengine.pdfdocumentextracter(pdfurl)\\n summary = wisdomaiengine.summarisepdfdocument(text)\\n topics = wisdomaiengine.wordcloud(search_me, text)\\n if topics is None:\\n topics = ['No Topics Found']\\n # write data to arxiv collection\\n search_term = db_search_terms.find_one({\\\"value\\\": search_me.lower()})\\n search_id = search_term.get(\\\"_id\\\")\\n data = {\\\"search_id\\\": search_id,\\n \\\"url\\\": pdfurl,\\n \\\"source\\\": source,\\n \\\"text\\\": text,\\n \\\"summary\\\": summary,\\n \\\"topics\\\": topics,\\n \\\"last_updated\\\": datetime.utcnow()}\\n x = db_summaries.insert(data, check_keys=False)\\n # return json\\n summaryjson = jsonify(wisdomtopics=topics, wisdomsummary=summary)\\n return summaryjson\",\n \"def get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode):\\r\\n cnt_list =[]\\r\\n for b, g_wvi1 in enumerate(g_wvi):\\r\\n g_wc1 = g_wc[b]\\r\\n pr_wvi1 = pr_wvi[b]\\r\\n pr_wn1 = len(pr_wvi1)\\r\\n g_wn1 = g_wn[b]\\r\\n\\r\\n # Now sorting.\\r\\n # Sort based wc sequence.\\r\\n if mode == 'test':\\r\\n idx1 = argsort(array(g_wc1))\\r\\n elif mode == 'train':\\r\\n idx1 = list( range( g_wn1) )\\r\\n else:\\r\\n raise ValueError\\r\\n\\r\\n if g_wn1 != pr_wn1:\\r\\n cnt_list.append(0)\\r\\n continue\\r\\n else:\\r\\n flag = True\\r\\n for i_wn, idx11 in enumerate(idx1):\\r\\n g_wvi11 = g_wvi1[idx11]\\r\\n pr_wvi11 = pr_wvi1[i_wn]\\r\\n if g_wvi11 != pr_wvi11:\\r\\n flag = False\\r\\n # print(g_wv1, g_wv11)\\r\\n # print(pr_wv1, pr_wv11)\\r\\n # input('')\\r\\n break\\r\\n if flag:\\r\\n cnt_list.append(1)\\r\\n else:\\r\\n cnt_list.append(0)\\r\\n\\r\\n return cnt_list\",\n \"def get_wotd():\\n\\treturn wotd\",\n \"def _get_wred(self):\\n return self.__wred\",\n \"def _get_wred(self):\\n return self.__wred\",\n \"def _get_wred(self):\\n return self.__wred\",\n \"def svn_info_t_has_wc_info_get(svn_info_t_self): # real signature unknown; restored from __doc__\\n pass\",\n \"def get_warc(self):\\n raise NotImplementedError()\",\n \"def wing(self):\\n return\",\n \"def is_wcw(status):\\n test_text = ' '.join(status['text'].lower().split()) # Remove capital letters and excessive whitespace/linebreaks\\n usernames = ['just_to_say_bot', 'thisisjustbot', 'Dcd200S', 'willslostplum', 'sosweetbot', 'JustToSayBot', 'thatisjustplums', \\\\\\n\\t\\t 'EatenBot', 'the_niche_bot', 'KristenCostel10', 'litabottal', 'pythonnina', 'alatest5', 'LisaRob96585017','Stilson28400122', \\\\\\n\\t\\t 'JohnDun40217560','Cordelia28', 'Rick63556459', 'botsnthings', 'timbot301', 'Rachel53001595', 'NicholasMillma6', 'ThisIsJustTo1'\\\\\\n\\t\\t'MayISay4', 'breakfast_plum', 'BotBot53368932'] # Block screen_names of known parody accounts\\n if status['user']['screen_name'] not in usernames and all(u not in status['text'] for u in usernames) and 'Cheap Bots, Done Quick!' not in status['source']:\\n if 'which you were probably' in test_text: # Capture parodies of the form\\n return True\\n elif 'plums' in test_text and 'icebox' in test_text: # Capture parodies of the content\\n return True\\n elif 'plum' in test_text and 'icebox' in test_text: # Capture singular 'plum'\\n return True\\n elif 'plums' in test_text and 'ice box' in test_text: #Capture 'ice box' with a space\\n return True\\n elif 'plum' in test_text and 'ice box' in test_text: \\n return True\\n elif 'William Carlos Williams'.lower() in test_text and 'plums' in test_text: #Capture mentions of WCW\\n return True\\n elif 'William Carlos Williams'.lower() in test_text and 'plum' in test_text:\\n return True\\n elif 'this is just to say' in test_text and 'that were in' in test_text: # Get only relevant instances of \\\"this is just to say\\\"\\n return True\\n elif 'this is just to say' in test_text and 'forgive me' in test_text:\\n return True\\n elif 'this is just to say' in test_text and 'and so' in test_text:\\n return True\\n elif 'so sweet and so cold' in test_text and 'the arms of the ocean' not in test_text: # Get 'so sweet and so cold' tweets that aren't quoting Florence and the Machine\\n return True\\n else:\\n return False\\n else:\\n return False\",\n \"def get_WS(w2v):\\n # get set of MAX_NGRAM-grams in text\\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 ngrams_in_data = set()\\n for words in raw:\\n for ngram in tweet_to_ngrams(words):\\n ngrams_in_data.add(ngram)\\n\\n # load sentiment features from model\\n clf_pipe = pickle.load(open(CLF_FNAME, 'rb')) # model\\n\\n vect = clf_pipe.best_estimator_.named_steps['vect']\\n clf = clf_pipe.best_estimator_.named_steps['clf']\\n\\n features_to_sent_idx = vect.vocabulary_ # map from model features to sentiment index\\n # currently, sentiment = 2 * (count_pos / (count_pos + count_neg)) - 1\\n sentiments = clf.feature_count_[1,:] / np.sum(clf.feature_count_, axis=0) # in [0,1]\\n sentiments = 2 * sentiments - 1 # rescale to [-1,1]\\n\\n features_to_sent = {feat: sentiments[idx] for (feat,idx) in features_to_sent_idx.items()}\\n\\n # build WS and ngram_idx_map for each MAX_NGRAM-gram in the text\\n k = len(next(iter(w2v.values()))) # dimension of embedding\\n WS = np.zeros(shape=(len(ngrams_in_data) + 1, k + MAX_NGRAM), dtype='float32')\\n ngram_idx_map = {}\\n\\n index = 1 # first row is left 0, for padding in the cnn. This is also neutral sentiment.\\n # For Vader Sentiment analysis\\n# vader_analyzer = SentimentIntensityAnalyzer()\\n\\n\\n for ngram in ngrams_in_data:\\n ngram_idx_map[ngram] = index\\n\\n # set word embedding, note that unknown words already randomized in load_embedding \\n words = ngram.split(' ')\\n WS[index,:k] = w2v[words[-1]] # embedding of last word\\n\\n # set sentiment embedding\\n for n in range(MAX_NGRAM): # for 1, 2, ... length ngrams\\n sub_ngram = ' '.join(words[-1 - n:]) \\n\\n # Naive Bayes Sentiment feature --------------------------------\\n sent = features_to_sent.get(sub_ngram, 0.0) # default to neutral 0\\n # --------------------------------------------------------------\\n\\n# # TextBlob sentiment feature -----------------------------------\\n# sent = TextBlob(sub_ngram).sentiment.polarity\\n# # --------------------------------------------------------------\\n\\n# # Vader sentiment feature -------------------------------------\\n# sent = vader_analyzer.polarity_scores(sub_ngram)['compound']\\n# # -------------------------------------------------------------\\n WS[index,k+n] = sent\\n\\n index += 1\\n\\n return WS, ngram_idx_map\",\n \"def combined_wcs(self) -> BaseHighLevelWCS:\",\n \"def get_cnt_sw_list(g_sc, g_sa, g_wn, g_wc, g_wo, g_wvi,\\r\\n pr_sc, pr_sa, pr_wn, pr_wc, pr_wo, pr_wvi,\\r\\n g_sql_i, pr_sql_i,\\r\\n mode):\\r\\n cnt_sc = get_cnt_sc_list(g_sc, pr_sc)\\r\\n cnt_sa = get_cnt_sc_list(g_sa, pr_sa)\\r\\n cnt_wn = get_cnt_sc_list(g_wn, pr_wn)\\r\\n cnt_wc = get_cnt_wc_list(g_wc, pr_wc)\\r\\n cnt_wo = get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode)\\r\\n if pr_wvi:\\r\\n cnt_wvi = get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode)\\r\\n else:\\r\\n cnt_wvi = [0]*len(cnt_sc)\\r\\n cnt_wv = get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode) # compare using wv-str which presented in original data.\\r\\n\\r\\n\\r\\n return cnt_sc, cnt_sa, cnt_wn, cnt_wc, cnt_wo, cnt_wvi, cnt_wv\",\n \"def handlehtmlsearch_wok(querystring, keywordstring, searchlimit, cache, smartconstrain):\\n mpsearch, keywords, constraints = handlehtmlsearch_mp(querystring, keywordstring, cache, smartconstrain)\\n\\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'rt') as record:\\n try:\\n wlist = json.load(record)\\n except ValueError:\\n wlist = {}\\n\\n searchtotal = 0\\n for search in mpsearch:\\n searchtotal += len(search)\\n\\n wokresults = []\\n i = 0\\n\\n for search in mpsearch:\\n for n in search:\\n iterinput = []\\n for m in n['unit_cell_formula'].keys():\\n iterinput.append(m + str(int(n['unit_cell_formula'][m])))\\n\\n iterlist = list(itertools.permutations(iterinput))\\n\\n searchparam = 'topic:' + n['pretty_formula'] + ' or topic:' + n['full_formula']\\n\\n for term in iterlist:\\n searchparam += ' or topic:' + ''.join(term)\\n\\n i += 1\\n if n['material_id'] in wlist.keys() and cache:\\n print('loading wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\\n wokresults.append(wlist[n['material_id']])\\n else:\\n print('searching wok for ' + n['full_formula'] + ' (' + str(i) + '/' + str(searchtotal) + ')')\\n try:\\n searchdata = searchWoKTools.getsearchdata(searchparam, searchlimit)\\n except:\\n with open('wokRecord.json', 'wt') as record:\\n json.dump(wlist, record)\\n raise\\n\\n searchdata[0].update(n)\\n wlist[n['material_id']] = searchdata\\n wokresults.append(searchdata)\\n\\n mpsearch, wokresults = searchWoKTools.removeconstrainedwok(mpsearch, wokresults, constraints)\\n\\n with open(os.path.join(os.getcwd(), 'resources', 'json','wokRecord.json'), 'wt') as record:\\n json.dump(wlist, record)\\n\\n keyresults = []\\n for search in wokresults:\\n keyresults.append(searchWoKTools.getkeylist(search, keywords))\\n\\n return keywords, mpsearch, wokresults, keyresults\",\n \"def pwgrwlfilter(self):\\n return None\",\n \"def treat_page(self):\\n # let's define some basic variables\\n urtext = self.current_page.text\\n urlang = self.current_page.site.code\\n urtitle = self.current_page.title()\\n urcat = []\\n eng_site = pywikibot.Site('en')\\n eng_title = ''\\n \\n interDict = {}\\n try:\\n site = pywikibot.Site('ur', 'wikipedia')\\n urpage = pywikibot.Page(site, urtitle)\\n langlst = urpage.iterlanglinks()\\n\\n \\n for i in langlst:\\n lang = str(i.site).split(':')[1]\\n interDict[lang] = i.title\\n \\n eng_title = interDict['en']\\n except:\\n pywikibot.output(u'\\\\03{lightred}Unable to fetch interwiki links!\\\\03{default}')\\n return False\\n \\n site = pywikibot.Site('en', 'wikipedia')\\n enpage = pywikibot.Page(site, eng_title)\\n\\n wikitext = enpage.get() \\n wikicode = mwp.parse(wikitext)\\n\\n # Extracting sfn templates and converting them in REF tags\\n sfnlist = []\\n for template in wikicode.filter_templates():\\n if template.name in ('sfn', 'sfn'):\\n sfnlist.append(template)\\n templ_rep = '<ref>' + str(template) + '</ref>'\\n wikicode.replace(template , templ_rep)\\n\\n alltags = wikicode.filter_tags() \\n reftags = {}\\n \\n def search(myDict, search1):\\n for key, value in myDict.items():\\n if search1 in value: \\n return key \\n \\n i=1\\n for tag in alltags:\\n if tag.tag=='ref':\\n if tag.attributes == []: # check if attributes list is empty\\n refval='NoRefName' # Reference has no name so assigning \\\"NoRefName\\\"\\n else:\\n name = tag.attributes[0]\\n refval = name.value\\n \\n if tag.contents is None:\\n #conval = search(reftags,refval)\\n #reftags[i] = (refval,reftags[conval][1])\\n pass\\n else: \\n reftags[i] = (refval,tag.contents)\\n i += 1\\n\\n dlinks = {}\\n for k,v in reftags.items():\\n dkey = 'و' + str(k) + 'و'\\n dlinks[dkey] = '<ref>' + str(v[1]) + '</ref>'\\n\\n urtext = urpage.text\\n for r in tuple(dlinks.items()):\\n urtext = urtext.replace(*r)\\n\\n # newln = '\\\\n'\\n # Using noreferences to add Reference template if not present\\n self.norefbot = noreferences.NoReferencesBot(None)\\n if self.norefbot.lacksReferences(urtext):\\n urtext = self.norefbot.addReferences(urtext)\\n else:\\n urpage.text = urtext + '\\\\n'\\n\\n print(urpage.text)\\n \\n # save the page \\n urpage.save(summary=self.summary, minor=False)\\n #self.put_current(urpage.text, summary=self.summary)\",\n \"def CC_wdw(self):\\n # Setup param\\n loc = 'TSdata'\\n if 'single' == self.newParam['survey_type']:\\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc).shape[0]\\n elif 'multiple' == self.newParam['survey_type']:\\n TS_group = dt.utilities.DB_group_names(self.Database, group_name = loc)[0]\\n TS_len = dt.utilities.DB_pd_data_load(self.Database, loc+'/'+TS_group).shape[0]\\n\\n param = self.newParam\\n\\n # Assign TS processing length to end_wdws if given\\n if param['end_wdws']:\\n TS_sig_len = param['end_wdws']\\n else:\\n TS_sig_len = TS_len\\n\\n ERROR_MESSAGE = 'The length of a TS signal to be processed is', TS_sig_len, \\\\\\n 'which is < end of the last window'\\n\\n # Calculate wdwPos for overlapping windows of ww_ol if wdwPos is False\\n if param['wdwPos'][0] is False:\\n # Error checks\\n if TS_sig_len < self.newParam['ww'][0]:\\n raise Warning(ERROR_MESSAGE)\\n\\n wdwStep = np.floor(param['ww'][0] *\\n (100 - param['ww_ol']) / 100)\\n\\n if self.verbose: print('* Length fo TSdata', TS_len)\\n\\n max_wdwPos = TS_sig_len - param['ww'][0] + 1\\n wdwStarts = np.arange(0 + param['sta_wdws'], max_wdwPos, wdwStep).astype(int)\\n\\n if self.verbose: print('* The step in window potions is %s sample points' % wdwStep)\\n if self.verbose: print('* The max window postions is %s sample points'% max_wdwPos)\\n\\n param['wdwPos'] = [ [wdw_start, wdw_start + param['ww'][0]] for\\n wdw_start in wdwStarts ]\\n\\n # Only update wdwPos structure if not already done so\\n elif np.array(param['wdwPos'][0]).shape == ():\\n param['wdwPos'] = [ [wdw_start, wdw_start + ww] for wdw_start,ww in\\n zip(param['wdwPos'], param['ww'])]\\n\\n self.newParam['wdwPos'] = param['wdwPos']\",\n \"def fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw):\\n\\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\\n\\tTocwf=Vk*Ck*Dk/GDen\\n\\treturn Tocwf\",\n \"def buildWPriorTerm(self):\\r\\n\\r\\n # self.w_prior.shape == (minibatch size,)\\r\\n self.w_prior = 0.5*T.sum(1 + T.log(self.qwgy_var) - self.qwgy_mu**2-self.qwgy_var, axis=1)\\r\\n\\r\\n self.w_prior_modif = - T.maximum(self.hyper['treshold_w_prior'], -self.w_prior)\",\n \"def wkt(self): # -> str:\\n ...\",\n \"def _new_wos_dict():\\n wos_dict = {\\n 'DI': None,\\n 'TI': None,\\n 'PY': None,\\n 'SO': None,\\n 'UT': None,\\n 'DE': None,\\n }\\n\\n return wos_dict\",\n \"def wing_geom_eval(self, cpacs):\\n\\n log.info(\\\"---------- Analysing wing geometry ----------\\\")\\n\\n # Opening tixi and tigl\\n tixi = cpacs.tixi\\n tigl = cpacs.tigl\\n\\n # Counting wing number without symmetry --------------------------------------\\n w_nb = tixi.getNamedChildrenCount(WINGS_XPATH, \\\"wing\\\")\\n\\n # INITIALIZATION 1 -----------------------------------------------------------\\n self.w_nb = w_nb\\n self.wing_nb = w_nb\\n wing_plt_area_xz = []\\n wing_plt_area_yz = []\\n wingUID = []\\n\\n # Counting sections and segments----------------------------------------------\\n b = 0\\n for i in range(1, w_nb + 1):\\n double = 1\\n self.wing_sym.append(tigl.wingGetSymmetry(i))\\n if self.wing_sym[i - 1] != 0:\\n double = 2 # To consider the real amount of wing\\n # when they are defined using symmetry\\n self.wing_nb += 1\\n self.wing_sec_nb.append(tigl.wingGetSectionCount(i))\\n self.wing_seg_nb.append(tigl.wingGetSegmentCount(i))\\n self.wing_vol.append(tigl.wingGetVolume(i) * double)\\n\\n self.wing_plt_area.append(tigl.wingGetReferenceArea(i, 1) * double) # x-y plane\\n wing_plt_area_xz.append(tigl.wingGetReferenceArea(i, 2) * double) # x-z plane\\n wing_plt_area_yz.append(tigl.wingGetReferenceArea(i, 3) * double) # y-z plane\\n\\n self.wing_tot_vol = self.wing_tot_vol + self.wing_vol[i - 1]\\n wingUID.append(tigl.wingGetUID(i))\\n self.wing_span.append(tigl.wingGetSpan(wingUID[i - 1]))\\n a = np.amax(self.wing_span)\\n # Evaluating the index that corresponds to the main wing\\n if a > b:\\n self.main_wing_index = i\\n b = a\\n\\n # Checking segment and section connection and reordering them\\n (\\n self.wing_sec_nb,\\n _,\\n seg_sec,\\n _,\\n ) = self.wing_check_segment_connection(wing_plt_area_xz, wing_plt_area_yz, tigl)\\n\\n # INITIALIZATION 2 -----------------------------------------------------------\\n\\n max_wing_sec_nb = np.amax(self.wing_sec_nb)\\n max_wing_seg_nb = np.amax(self.wing_seg_nb)\\n wing_center_section_point = np.zeros((max_wing_sec_nb, w_nb, 3))\\n self.wing_center_seg_point = np.zeros((max_wing_seg_nb, self.wing_nb, 3))\\n self.wing_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\\n self.wing_fuel_seg_vol = np.zeros((max_wing_seg_nb, w_nb))\\n self.wing_fuel_vol = 0\\n self.wing_mac = np.zeros((4, w_nb))\\n self.wing_sec_thickness = np.zeros((max_wing_sec_nb + 1, w_nb))\\n\\n # WING ANALYSIS --------------------------------------------------------------\\n\\n # Main wing plantform area\\n self.wing_plt_area_main = self.wing_plt_area[self.main_wing_index - 1]\\n\\n # Wing: MAC,chords,thickness,span,plantform area ------------------------------\\n\\n for i in range(1, w_nb + 1):\\n mac = tigl.wingGetMAC(wingUID[i - 1])\\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, 1, 0.0, 0.0)\\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, 1, 0.0, 1.0)\\n self.wing_max_chord.append(\\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\\n )\\n wpx, wpy, wpz = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 0.0)\\n wpx2, wpy2, wpz2 = tigl.wingGetChordPoint(i, self.wing_seg_nb[i - 1], 1.0, 1.0)\\n self.wing_min_chord.append(\\n np.sqrt((wpx2 - wpx) ** 2 + (wpy2 - wpy) ** 2 + (wpz2 - wpz) ** 2)\\n )\\n for k in range(1, 5):\\n self.wing_mac[k - 1][i - 1] = mac[k - 1]\\n for jj in range(1, self.wing_seg_nb[i - 1] + 1):\\n j = int(seg_sec[jj - 1, i - 1, 2])\\n cle = tigl.wingGetChordPoint(i, j, 0.0, 0.0)\\n self.wing_seg_vol[j - 1][i - 1] = tigl.wingGetSegmentVolume(i, j)\\n lp = tigl.wingGetLowerPoint(i, j, 0.0, 0.0)\\n up = tigl.wingGetUpperPoint(i, j, 0.0, 0.0)\\n if np.all(cle == lp):\\n L = 0.25\\n else:\\n L = 0.75\\n if np.all(cle == up):\\n U = 0.25\\n else:\\n U = 0.75\\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, j, 0.0, L)\\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, j, 0.0, U)\\n wing_center_section_point[j - 1][i - 1][0] = (wplx + wpux) / 2\\n wing_center_section_point[j - 1][i - 1][1] = (wply + wpuy) / 2\\n wing_center_section_point[j - 1][i - 1][2] = (wplz + wpuz) / 2\\n self.wing_sec_thickness[j - 1][i - 1] = np.sqrt(\\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\\n )\\n j = int(seg_sec[self.wing_seg_nb[i - 1] - 1, i - 1, 2])\\n wplx, wply, wplz = tigl.wingGetLowerPoint(i, self.wing_seg_nb[i - 1], 1.0, L)\\n wpux, wpuy, wpuz = tigl.wingGetUpperPoint(i, self.wing_seg_nb[i - 1], 1.0, U)\\n self.wing_sec_thickness[j][i - 1] = np.sqrt(\\n (wpux - wplx) ** 2 + (wpuy - wply) ** 2 + (wpuz - wplz) ** 2\\n )\\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][0] = (wplx + wpux) / 2\\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][1] = (wply + wpuy) / 2\\n wing_center_section_point[self.wing_seg_nb[i - 1]][i - 1][2] = (wplz + wpuz) / 2\\n self.wing_sec_mean_thick.append(\\n np.mean(self.wing_sec_thickness[0 : self.wing_seg_nb[i - 1] + 1, i - 1])\\n )\\n # Evaluating wing fuel tank volume in the main wings\\n if abs(round(self.wing_plt_area[i - 1], 3) - self.wing_plt_area_main) < 0.001:\\n tp_ratio = self.wing_min_chord[i - 1] / self.wing_max_chord[i - 1]\\n ratio = round(tp_ratio * self.wing_plt_area[i - 1] / 100, 1)\\n if ratio >= 1.0:\\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.8, 2)\\n elif ratio >= 0.5:\\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.72, 2)\\n else:\\n self.wing_fuel_vol = round(self.wing_vol[i - 1] * 0.5, 2)\\n for j in seg_sec[:, i - 1, 2]:\\n if j == 0.0:\\n break\\n self.wing_fuel_seg_vol[int(j) - 1][i - 1] = round(\\n (self.wing_seg_vol[int(j) - 1][i - 1] / (sum(self.wing_vol)))\\n * self.wing_fuel_vol,\\n 2,\\n )\\n if (\\n self.wing_plt_area[i - 1] > wing_plt_area_xz[i - 1]\\n and self.wing_plt_area[i - 1] > wing_plt_area_yz[i - 1]\\n ):\\n self.is_horiz.append(True)\\n if self.wing_sym[i - 1] != 0:\\n self.is_horiz.append(True)\\n else:\\n self.is_horiz.append(False)\\n if self.wing_sym[i - 1] != 0:\\n self.is_horiz.append(False)\\n\\n # Wing segment length evaluating function\\n self.get_wing_segment_length(wing_center_section_point)\\n\\n # Evaluating the point at the center of each segment, the center\\n # is placed at 1/4 of the chord, symmetry is considered.\\n\\n a = 0\\n c = False\\n for i in range(1, int(self.wing_nb) + 1):\\n if c:\\n c = False\\n continue\\n for jj in range(1, self.wing_seg_nb[i - a - 1] + 1):\\n j = int(seg_sec[jj - 1, i - a - 1, 2])\\n self.wing_center_seg_point[j - 1][i - 1][0] = (\\n wing_center_section_point[j - 1][i - a - 1][0]\\n + wing_center_section_point[j][i - a - 1][0]\\n ) / 2\\n self.wing_center_seg_point[j - 1][i - 1][1] = (\\n wing_center_section_point[j - 1][i - a - 1][1]\\n + wing_center_section_point[j][i - a - 1][1]\\n ) / 2\\n self.wing_center_seg_point[j - 1][i - 1][2] = (\\n wing_center_section_point[j - 1][i - a - 1][2]\\n + wing_center_section_point[j][i - a - 1][2]\\n ) / 2\\n if self.wing_sym[i - 1 - a] != 0:\\n if self.wing_sym[i - 1 - a] == 1:\\n symy = 1\\n symx = 1\\n symz = -1\\n if self.wing_sym[i - 1 - a] == 2:\\n symy = -1\\n symx = 1\\n symz = 1\\n if self.wing_sym[i - 1 - a] == 3:\\n symy = 1\\n symx = -1\\n symz = 1\\n self.wing_center_seg_point[:, i, 0] = (\\n self.wing_center_seg_point[:, i - 1, 0] * symx\\n )\\n self.wing_center_seg_point[:, i, 1] = (\\n self.wing_center_seg_point[:, i - 1, 1] * symy\\n )\\n self.wing_center_seg_point[:, i, 2] = (\\n self.wing_center_seg_point[:, i - 1, 2] * symz\\n )\\n c = True\\n a += 1\\n\\n self.w_seg_sec = seg_sec\\n\\n self.wing_area = round(self.wing_plt_area_main, 3)\\n\\n log.info(\\\"---------------------------------------------\\\")\\n log.info(\\\"--------------- Wing Results ----------------\\\")\\n log.info(f\\\"Number of Wings [-]: {self.wing_nb}\\\")\\n log.info(f\\\"Wing symmetry plane [-]: {self.wing_sym}\\\")\\n log.info(f\\\"Number of wing sections (not counting symmetry) [-]: {self.wing_sec_nb}\\\")\\n log.info(f\\\"Number of wing segments (not counting symmetry) [-]: {self.wing_seg_nb}\\\")\\n log.info(f\\\"Wing Span [m]: {self.wing_span}\\\")\\n log.info(f\\\"Wing MAC length [m]: {self.wing_mac[0,]}\\\")\\n log.info(f\\\"Wing max chord length [m]: {self.wing_max_chord}\\\")\\n log.info(f\\\"Wing min chord length [m]: {self.wing_min_chord}\\\")\\n log.info(f\\\"Main wing plantform area [m^2]: {self.wing_plt_area_main}\\\")\\n log.info(f\\\"Wings plantform area [m^2]: {self.wing_plt_area}\\\")\\n log.info(f\\\"Volume of each wing [m^3]: {self.wing_vol}\\\")\\n log.info(f\\\"Total wing volume [m^3]: {self.wing_tot_vol}\\\")\\n log.info(f\\\"Wing volume for fuel storage [m^3]: {self.wing_fuel_vol}\\\")\\n log.info(\\\"---------------------------------------------\\\")\",\n \"def get_wo_mthly_smry(self, workorder_browse):\\n wo_summary_data = []\\n wo_check_dict = {}\\n no = 0\\n if workorder_browse:\\n for work_rec in workorder_browse:\\n if work_rec.state and work_rec.state == \\\"done\\\":\\n no += 1\\n identification = \\\"\\\"\\n repair_line_data = \\\"\\\"\\n if work_rec.vehicle_id:\\n identification += work_rec.vehicle_id.name\\n if work_rec.vehicle_id.f_brand_id:\\n identification += \\\" \\\" + work_rec.vehicle_id.f_brand_id.name\\n if work_rec.vehicle_id.model_id:\\n identification += \\\" \\\" + work_rec.vehicle_id.model_id.name\\n for repaire_line in work_rec.repair_line_ids:\\n if repaire_line.complete is True:\\n if (\\n repaire_line.repair_type_id\\n and repaire_line.repair_type_id.name\\n ):\\n repair_line_data += (\\n repaire_line.repair_type_id.name + \\\", \\\"\\n )\\n if work_rec.parts_ids:\\n for parts_line in work_rec.parts_ids:\\n if work_rec.id in wo_check_dict.keys():\\n parts_data = {\\n \\\"no\\\": -1,\\n \\\"location\\\": \\\"\\\",\\n \\\"type\\\": \\\"\\\",\\n \\\"wo\\\": \\\"\\\",\\n \\\"identification\\\": \\\"\\\",\\n \\\"vin\\\": \\\"\\\",\\n \\\"plate_no\\\": \\\"\\\",\\n \\\"work_performed\\\": \\\"\\\",\\n \\\"part\\\": parts_line.product_id\\n and parts_line.product_id.default_code\\n or \\\"\\\",\\n \\\"qty\\\": parts_line.qty or 0.0,\\n \\\"uom\\\": parts_line.product_uom\\n and parts_line.product_uom.name\\n or \\\"\\\",\\n }\\n wo_summary_data.append(parts_data)\\n else:\\n wo_check_dict[work_rec.id] = work_rec.id\\n parts_data = {\\n \\\"no\\\": no,\\n \\\"location\\\": work_rec.team_id\\n and work_rec.team_id.name\\n or \\\"\\\",\\n \\\"type\\\": work_rec.main_type or \\\"\\\",\\n \\\"wo\\\": work_rec.name or \\\"\\\",\\n \\\"identification\\\": identification or \\\"\\\",\\n \\\"vin\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.vin_sn\\n or \\\"\\\",\\n \\\"plate_no\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.license_plate\\n or \\\"\\\",\\n \\\"work_performed\\\": repair_line_data\\n and repair_line_data[:-2]\\n or \\\"\\\",\\n \\\"part\\\": parts_line.product_id\\n and parts_line.product_id.default_code\\n or \\\"\\\",\\n \\\"qty\\\": parts_line.qty or 0.0,\\n \\\"uom\\\": parts_line.product_uom\\n and parts_line.product_uom.name\\n or \\\"\\\",\\n }\\n wo_summary_data.append(parts_data)\\n else:\\n parts_data = {\\n \\\"no\\\": no,\\n \\\"location\\\": work_rec.team_id\\n and work_rec.team_id.name\\n or \\\"\\\",\\n \\\"type\\\": work_rec.main_type or \\\"\\\",\\n \\\"wo\\\": work_rec.name or \\\"\\\",\\n \\\"identification\\\": identification or \\\"\\\",\\n \\\"vin\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.vin_sn\\n or \\\"\\\",\\n \\\"plate_no\\\": work_rec.vehicle_id\\n and work_rec.vehicle_id.license_plate\\n or \\\"\\\",\\n \\\"work_performed\\\": repair_line_data\\n and repair_line_data[:-2]\\n or \\\"\\\",\\n \\\"vehicle_make\\\": \\\"\\\",\\n \\\"qty\\\": \\\"\\\",\\n \\\"uom\\\": \\\"\\\",\\n }\\n wo_summary_data.append(parts_data)\\n if not wo_summary_data:\\n msg = _(\\n \\\"Warning! \\\\n\\\\\\n No data Available for selected work order.\\\"\\n )\\n raise UserError(msg)\\n return wo_summary_data\",\n \"def analyzeWeights(self, occludedPortions):\\r\\n\\t\\treturn None\",\n \"def update(self):\\n self.wc.update()\",\n \"def original_wcs(self):\\n return self._owcs\",\n \"def lookup(doc, wv):\\n checked = []\\n for word in doc:\\n try:\\n word in wv\\n except KeyError:\\n log.warning(\\\"Word not in model: %s\\\", word)\\n continue\\n checked.append(wv[word])\\n vec = np.mean(checked, axis=0)\\n return vec\",\n \"def give_wv_units(wave):\\n if not hasattr(wave, 'unit'):\\n uwave = u.Quantity(wave, unit=u.AA)\\n elif wave.unit is None:\\n uwave = u.Quantity(wave, unit=u.AA)\\n else:\\n uwave = u.Quantity(wave)\\n\\n return uwave\",\n \"def wrez2xml(self,newdoc,newroot):\\n\\t\\twrez = newdoc.createElement('wrez')\\n\\t\\twrez.setAttribute('hasChanged', str(self.hasChanged))\\n\\t\\tnewroot.appendChild(wrez)\\n\\n\\t\\tpath = newdoc.createElement('path')\\n\\t\\tpath.setAttribute('value', self.path)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('init_str')\\n\\t\\tpath.setAttribute('value', self.init_str)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('hash_sha512')\\n\\t\\tpath.setAttribute('value', self.hash_sha512)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('src_rip')\\n\\t\\tpath.setAttribute('value', self.src_rip)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('quality')\\n\\t\\tpath.setAttribute('value', self.quality)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('codec')\\n\\t\\tpath.setAttribute('value', self.codec)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('language')\\n\\t\\tpath.setAttribute('value', self.language)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('audio')\\n\\t\\tpath.setAttribute('value', self.audio)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('encoder')\\n\\t\\tpath.setAttribute('value', self.encoder)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('version')\\n\\t\\tpath.setAttribute('value', self.version)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('extension')\\n\\t\\tpath.setAttribute('value', self.extension)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('release_year')\\n\\t\\tpath.setAttribute('value', self.release_year)\\n\\t\\twrez.appendChild(path)\\n\\t\\n\\t\\tpath = newdoc.createElement('title')\\n\\t\\tpath.setAttribute('value', self.title)\\n\\t\\twrez.appendChild(path)\\n\\n\\t\\tpath = newdoc.createElement('size')\\n\\t\\tpath.setAttribute('value', str(self.size))\\n\\t\\twrez.appendChild(path)\\n\\t\\treturn wrez\",\n \"def get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode):\\r\\n cnt_list=[]\\r\\n for b, g_wo1 in enumerate(g_wo):\\r\\n g_wc1 = g_wc[b]\\r\\n pr_wc1 = pr_wc[b]\\r\\n pr_wo1 = pr_wo[b]\\r\\n pr_wn1 = len(pr_wo1)\\r\\n g_wn1 = g_wn[b]\\r\\n\\r\\n if g_wn1 != pr_wn1:\\r\\n cnt_list.append(0)\\r\\n continue\\r\\n else:\\r\\n # Sort based wc sequence.\\r\\n if mode == 'test':\\r\\n idx = argsort(array(g_wc1))\\r\\n\\r\\n g_wo1_s = array(g_wo1)[idx]\\r\\n g_wo1_s = list(g_wo1_s)\\r\\n elif mode == 'train':\\r\\n # due to tearch forcing, no need to sort.\\r\\n g_wo1_s = g_wo1\\r\\n else:\\r\\n raise ValueError\\r\\n\\r\\n if type(pr_wo1) != list:\\r\\n raise TypeError\\r\\n if g_wo1_s == pr_wo1:\\r\\n cnt_list.append(1)\\r\\n else:\\r\\n cnt_list.append(0)\\r\\n return cnt_list\",\n \"def onReload(self, event):\\n\\n\\t\\tself.wv.Reload()\",\n \"def test_mlpi_cwro(self):\\r\\n\\t\\twith open(\\\"test_mlpi_cwro.txt\\\", \\\"w\\\") as test_mlpi_cwro_output:\\r\\n\\t\\t\\tsys.stdout = test_mlpi_cwro_output\\r\\n\\t\\t\\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=100, censor_words_one_pass=True)\\r\\n\\t\\twith open(\\\"test_mlpi_cwro.txt\\\", \\\"r\\\") as test_mlpi_cwro_output:\\r\\n\\t\\t\\twhile True:\\r\\n\\t\\t\\t\\tline_output = test_mlpi_cwro_output.readline()\\r\\n\\t\\t\\t\\tline_correct = cc_test_prose.readline()\\r\\n\\t\\t\\t\\tself.assertEqual(line_output, line_correct)\\r\\n\\t\\t\\t\\tif line_correct == '':\\r\\n\\t\\t\\t\\t\\tbreak\\r\\n\\t\\tcc_test_prose.seek(0)\\r\\n\\t\\tsys.stdout = sys.__stdout__\\r\\n\\t\\tos.remove(\\\"test_mlpi_cwro.txt\\\")\",\n \"def primalrepair(self,wlc,wuc,wlx,wux): # 3\\n if wlc is None:\\n wlc_ = None\\n else:\\n try:\\n wlc_ = memoryview(wlc)\\n except TypeError:\\n try:\\n _tmparr_wlc = array.array(\\\"d\\\",wlc)\\n except TypeError:\\n raise TypeError(\\\"Argument wlc has wrong type\\\")\\n else:\\n wlc_ = memoryview(_tmparr_wlc)\\n \\n else:\\n if wlc_.format != \\\"d\\\":\\n wlc_ = memoryview(array.array(\\\"d\\\",wlc))\\n \\n if wlc_ is not None and len(wlc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wlc has wrong length\\\")\\n if wuc is None:\\n wuc_ = None\\n else:\\n try:\\n wuc_ = memoryview(wuc)\\n except TypeError:\\n try:\\n _tmparr_wuc = array.array(\\\"d\\\",wuc)\\n except TypeError:\\n raise TypeError(\\\"Argument wuc has wrong type\\\")\\n else:\\n wuc_ = memoryview(_tmparr_wuc)\\n \\n else:\\n if wuc_.format != \\\"d\\\":\\n wuc_ = memoryview(array.array(\\\"d\\\",wuc))\\n \\n if wuc_ is not None and len(wuc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wuc has wrong length\\\")\\n if wlx is None:\\n wlx_ = None\\n else:\\n try:\\n wlx_ = memoryview(wlx)\\n except TypeError:\\n try:\\n _tmparr_wlx = array.array(\\\"d\\\",wlx)\\n except TypeError:\\n raise TypeError(\\\"Argument wlx has wrong type\\\")\\n else:\\n wlx_ = memoryview(_tmparr_wlx)\\n \\n else:\\n if wlx_.format != \\\"d\\\":\\n wlx_ = memoryview(array.array(\\\"d\\\",wlx))\\n \\n if wlx_ is not None and len(wlx_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wlx has wrong length\\\")\\n if wux is None:\\n wux_ = None\\n else:\\n try:\\n wux_ = memoryview(wux)\\n except TypeError:\\n try:\\n _tmparr_wux = array.array(\\\"d\\\",wux)\\n except TypeError:\\n raise TypeError(\\\"Argument wux has wrong type\\\")\\n else:\\n wux_ = memoryview(_tmparr_wux)\\n \\n else:\\n if wux_.format != \\\"d\\\":\\n wux_ = memoryview(array.array(\\\"d\\\",wux))\\n \\n if wux_ is not None and len(wux_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wux has wrong length\\\")\\n res = self.__obj.primalrepair(wlc_,wuc_,wlx_,wux_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def primalrepair(self,wlc_,wuc_,wlx_,wux_):\\n _wlc_minlength = self.getnumcon()\\n if self.getnumcon() > 0 and wlc_ is not None and len(wlc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wlc is not long enough: Is %d, expected %d\\\" % (len(wlc_),self.getnumcon()))\\n if isinstance(wlc_, numpy.ndarray) and wlc_.dtype is numpy.dtype(numpy.float64) and wlc_.flags.contiguous:\\n _wlc_copyarray = False\\n _wlc_tmp = ctypes.cast(wlc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wlc_ is not None:\\n _wlc_copyarray = True\\n _wlc_np_tmp = numpy.zeros(len(wlc_),numpy.dtype(numpy.float64))\\n _wlc_np_tmp[:] = wlc_\\n assert _wlc_np_tmp.flags.contiguous\\n _wlc_tmp = ctypes.cast(_wlc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wlc_copyarray = False\\n _wlc_tmp = None\\n \\n _wuc_minlength = self.getnumcon()\\n if self.getnumcon() > 0 and wuc_ is not None and len(wuc_) != self.getnumcon():\\n raise ValueError(\\\"Array argument wuc is not long enough: Is %d, expected %d\\\" % (len(wuc_),self.getnumcon()))\\n if isinstance(wuc_, numpy.ndarray) and wuc_.dtype is numpy.dtype(numpy.float64) and wuc_.flags.contiguous:\\n _wuc_copyarray = False\\n _wuc_tmp = ctypes.cast(wuc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wuc_ is not None:\\n _wuc_copyarray = True\\n _wuc_np_tmp = numpy.zeros(len(wuc_),numpy.dtype(numpy.float64))\\n _wuc_np_tmp[:] = wuc_\\n assert _wuc_np_tmp.flags.contiguous\\n _wuc_tmp = ctypes.cast(_wuc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wuc_copyarray = False\\n _wuc_tmp = None\\n \\n _wlx_minlength = self.getnumvar()\\n if self.getnumvar() > 0 and wlx_ is not None and len(wlx_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wlx is not long enough: Is %d, expected %d\\\" % (len(wlx_),self.getnumvar()))\\n if isinstance(wlx_, numpy.ndarray) and wlx_.dtype is numpy.dtype(numpy.float64) and wlx_.flags.contiguous:\\n _wlx_copyarray = False\\n _wlx_tmp = ctypes.cast(wlx_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wlx_ is not None:\\n _wlx_copyarray = True\\n _wlx_np_tmp = numpy.zeros(len(wlx_),numpy.dtype(numpy.float64))\\n _wlx_np_tmp[:] = wlx_\\n assert _wlx_np_tmp.flags.contiguous\\n _wlx_tmp = ctypes.cast(_wlx_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wlx_copyarray = False\\n _wlx_tmp = None\\n \\n _wux_minlength = self.getnumvar()\\n if self.getnumvar() > 0 and wux_ is not None and len(wux_) != self.getnumvar():\\n raise ValueError(\\\"Array argument wux is not long enough: Is %d, expected %d\\\" % (len(wux_),self.getnumvar()))\\n if isinstance(wux_, numpy.ndarray) and wux_.dtype is numpy.dtype(numpy.float64) and wux_.flags.contiguous:\\n _wux_copyarray = False\\n _wux_tmp = ctypes.cast(wux_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif wux_ is not None:\\n _wux_copyarray = True\\n _wux_np_tmp = numpy.zeros(len(wux_),numpy.dtype(numpy.float64))\\n _wux_np_tmp[:] = wux_\\n assert _wux_np_tmp.flags.contiguous\\n _wux_tmp = ctypes.cast(_wux_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _wux_copyarray = False\\n _wux_tmp = None\\n \\n res = __library__.MSK_XX_primalrepair(self.__nativep,_wlc_tmp,_wuc_tmp,_wlx_tmp,_wux_tmp)\\n if res != 0:\\n _,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\",\n \"def vp():\\r\\n section = document.add_section()\\r\\n new_width, new_height = section.page_height, section.page_width\\r\\n section.orientation = WD_ORIENT.LANDSCAPE\\r\\n section.page_width = 10058400\\r\\n section.page_height = 7772400\\r\\n document.add_heading('Virtual Proxy details', 1)\\r\\n virtualproxy_metrics= ['description', 'prefix', 'authenticationModuleRedirectUri', 'sessionModuleBaseUri', 'loadBalancingModuleBaseUri', 'authenticationMethod', 'headerAuthenticationMode',\\r\\n 'headerAuthenticationHeaderName', 'headerAuthenticationStaticUserDirectory', 'headerAuthenticationDynamicUserDirectory', 'anonymousAccessMode', 'windowsAuthenticationEnabledDevicePattern',\\r\\n 'sessionCookieHeaderName', 'sessionCookieDomain', 'additionalResponseHeaders', 'sessionInactivityTimeout', 'extendedSecurityEnvironment', 'websocketCrossOriginWhiteList', 'defaultVirtualProxy',\\r\\n 'tags','samlMetadataIdP', 'samlHostUri', 'samlEntityId', 'samlAttributeUserId', 'samlAttributeUserDirectory', 'samlAttributeSigningAlgorithm', 'samlAttributeMap', 'magicLinkHostUri',\\r\\n 'magicLinkFriendlyName','jwtPublicKeyCertificate','jwtAttributeUserDirectory','jwtAttributeMap','jwtAttributeUserId']\\r\\n \\r\\n virtualproxynodes = get_qlik_sense.get_virtualproxy()\\r\\n num_of_virtualproxys = len(virtualproxynodes)\\r\\n num_of_virtualproxy_metrics = len(virtualproxy_metrics)\\r\\n table = document.add_table(rows=num_of_virtualproxy_metrics+1, cols=num_of_virtualproxys+1)\\r\\n table.style = 'Grid Table 1 Light Accent 1'\\r\\n row = table.rows[0]\\r\\n row.cells[0].text = 'Metric'\\r\\n for item in range(0, num_of_virtualproxys):\\r\\n row.cells[item+1].text = virtualproxynodes[item][29]\\r\\n for item in range(num_of_virtualproxy_metrics):\\r\\n row = table.rows[item+1]\\r\\n row.cells[0].text = str(virtualproxy_metrics[item])\\r\\n for virtualproxynode in range(num_of_virtualproxys):\\r\\n row.cells[virtualproxynode+1].text = str(virtualproxynodes[virtualproxynode][item])\\r\\n\\r\\n document.add_page_break()\",\n \"def get_bforce_wm_ws_Gx_surf(self):\\n\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w'] \\n \\n self.Gm1 = np.zeros([Ly])\\n self.dGm1_dS = np.zeros([Ly]) \\n self.Gt1 = np.zeros([Ly])\\n self.dGt1_dS = np.zeros([Ly]) \\n self.Bfsfc_bl = np.zeros([Ly])\\n self.Av_bl = np.zeros([Ly])\\n self.dAv_bl = np.zeros([Ly])\\n \\n #debugging\\n self.wm_surf = np.zeros([Ly])\\n self.ws_surf = np.zeros([Ly]) \\n\\n #---> j-loop\\n for j in range(Ly): \\n k_w = self.kbl[j] # KBL is \\\"new bl index after calling find_new_kbl()\\n z_bl = z_u_w[j,N] - self.hbls[j]\\n zscale = self.hbls[j] \\n \\n if self.swr_frac[j,k_w-1] > 0:\\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\\n \\n else:\\n Bfsfc = self.Bo[j] + self.Bosol[j]\\n \\n # CALCUALTE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm_surf[j] = wm\\n self.ws_surf[j] = ws \\n\\n if self.LIMIT_UNSTABLE_ONLY:\\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\\n else:\\n f1 = 0\\n\\n \\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n\\n #MOMENTUM \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl[j] = Av_bl\\n self.dAv_bl[j] = dAv_bl\\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \\n\\n #TEMPERATURE(BUOYANCY)\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \\n\\n self.Bfsfc_bl[j] = Bfsfc\",\n \"def get_w(self):\\n raise NotImplementedError\",\n \"def propose(self):\\n\\n\\n fb = 0.0\\n changed_any = False\\n\\n while not changed_any:\\n new = copy(self) ## Now we just copy the whole thing\\n\\n for w in self.all_words():\\n if flip(self.propose_p):\\n try:\\n xp, xfb = self.get_word(w).propose()\\n\\n changed_any = True\\n new.set_word(w, xp)\\n fb += xfb\\n\\n except ProposalFailedException:\\n pass\\n\\n\\n return new, fb\",\n \"def build_W(points):\\n return None\",\n \"def computeW(self):\\n E = np.where(self.v > 0, 1, -1)\\n # theshold the connections to only -1,1\\n binary_weights = np.where(self.c > 0, 1, self.c)\\n binary_weights = np.where(binary_weights < 0, -1, binary_weights)\\n W = np.sum(binary_weights * np.dot(E.reshape(-1,1), E.reshape(1,-1))) # W = C * E * E\\n self.W = W\\n if np.sum(binary_weights) != 0:\\n self.W = self.W / np.sum(binary_weights) # W / W*\\n return self.W\",\n \"def vcac_worklfow_request(self):\\n logging.info(\\\"Inside ucsvm_worklfow_request method base class\\\")\\n return None\",\n \"def get_wordcloud():\\n params = request.args\\n result = None\\n\\n def set_result(x):\\n nonlocal result # This is ugly, ew, gotta fix this\\n result = x\\n\\n pipeline_zoo.get_full_word_distribution(set_result).feed_data((params, None))\\n return jsonify({\\n 'word_distribution': result\\n })\",\n \"def get_vector(word, model):\\n return model.wv[word]\",\n \"def new_words_only(base_words, window_words):\\n new_words = []\\n if base_words:\\n for wword in window_words:\\n dont_include = False\\n for bword in base_words:\\n if CharNetRunner._do_words_intersect(wword, bword):\\n dont_include = True\\n break\\n if not dont_include:\\n new_words.append(wword)\\n else:\\n new_words = window_words\\n\\n return new_words\",\n \"def search_clues(self):\\r\\n print(\\\"\\\\n************Searching Clues************\\\\n\\\")\\r\\n for word_id in self.words.keys():\\r\\n if not self.words[word_id].see and not self.words[word_id].wth:\\r\\n clue = pop_backslash(self.words[word_id].clue)\\r\\n temp = word_domain(\\\"allintext:\\\" + clue +' -crossword',self.words[word_id].length)\\r\\n temp2 = temp + word_domain(clue +' -crossword',self.words[word_id].length)\\r\\n domain = temp2 + data_muse(clue, self.words[word_id].length)\\r\\n unique_list = []\\r\\n for x in domain: \\r\\n y = x.upper()\\r\\n # check if exists in unique_list or not \\r\\n if y not in unique_list: \\r\\n unique_list.append(y) \\r\\n \\r\\n self.words[word_id].assign_word_domain(unique_list)\\r\\n print(\\\"\\\\nSearch is done...\\\")\",\n \"def build_parameters(pobj):\\n ViscosityWilke.build_parameters(pobj)\",\n \"def wps(model, data):\\n with msg.loading(f\\\"Loading model '{model}'...\\\"):\\n nlp = spacy.load(model)\\n texts = (eg[\\\"text\\\"] for eg in srsly.read_jsonl(data))\\n n_docs = 0\\n n_words = 0\\n start_time = timer()\\n for doc in nlp.pipe(texts):\\n n_docs += 1\\n n_words += len(doc)\\n end_time = timer()\\n wps = int(n_words / (end_time - start_time))\\n result = [\\n (\\\"Docs\\\", f\\\"{n_docs:,}\\\"),\\n (\\\"Words\\\", f\\\"{n_words:,}\\\"),\\n (\\\"Words/s\\\", f\\\"{wps:,}\\\"),\\n ]\\n msg.table(result, widths=(7, 12), aligns=(\\\"l\\\", \\\"r\\\"))\",\n \"def get_doc_prov(j, gcis_url, refList):\\n gcis_ns = \\\"https://gcis-search-stage.jpl.net:3000/gcis.owl#\\\"\\n doc = ProvEsDocument()\\n bndl = None\\n \\n#to get people attributed to, you need to grab article -> jornal_identifier -> look up in references\\n# for ref in refList:\\n# if ref['child_publication'] == j['uri']:\\n \\n\\n\\n doc_attrs = [\\n (\\\"prov:type\\\", 'gcis:Article'),\\n (\\\"prov:label\\\", j['title']),\\n (\\\"prov:location\\\", j['uri']),\\n #(\\\"prov:wasAttributedTo\\\", j['']),\\n ]\\n doc.entity('bibo:%s' % j['identifier'], doc_attrs)\\n\\n prov_json = json.loads(doc.serialize())\\n\\n return prov_json\",\n \"def isMWS_WD(primary=None, gaia=None, galb=None, astrometricexcessnoise=None,\\n pmra=None, pmdec=None, parallax=None, parallaxovererror=None,\\n photbprpexcessfactor=None, astrometricsigma5dmax=None,\\n gaiagmag=None, gaiabmag=None, gaiarmag=None, paramssolved=None):\\n if primary is None:\\n primary = np.ones_like(gaia, dtype='?')\\n mws = primary.copy()\\n\\n # ADM do not target any objects for which entries are NaN\\n # ADM and turn off the NaNs for those entries.\\n if photbprpexcessfactor is not None:\\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\\n np.isnan(parallax) | np.isnan(photbprpexcessfactor))\\n else:\\n nans = (np.isnan(gaiagmag) | np.isnan(gaiabmag) | np.isnan(gaiarmag) |\\n np.isnan(parallax))\\n w = np.where(nans)[0]\\n if len(w) > 0:\\n parallax, gaiagmag = parallax.copy(), gaiagmag.copy()\\n gaiabmag, gaiarmag = gaiabmag.copy(), gaiarmag.copy()\\n if photbprpexcessfactor is not None:\\n photbprpexcessfactor = photbprpexcessfactor.copy()\\n # ADM safe to make these zero regardless of cuts as...\\n photbprpexcessfactor[w] = 0.\\n parallax[w] = 0.\\n gaiagmag[w], gaiabmag[w], gaiarmag[w] = 0., 0., 0.\\n # ADM ...we'll turn off all bits here.\\n mws &= ~nans\\n# log.info('{}/{} NaNs in file...t = {:.1f}s'\\n# .format(len(w), len(mws), time()-start))\\n\\n # ADM apply the selection for all MWS-WD targets\\n # ADM must be a Legacy Surveys object that matches a Gaia source\\n mws &= gaia\\n\\n # ADM and all astrometric parameters are measured.\\n mws &= paramssolved == 31\\n\\n # ADM Gaia G mag of less than 20\\n mws &= gaiagmag < 20.\\n\\n # ADM Galactic b at least 20o from the plane\\n mws &= np.abs(galb) > 20.\\n\\n # ADM gentle cut on parallax significance\\n mws &= parallaxovererror > 1.\\n\\n # ADM Color/absolute magnitude cuts of (defining the WD cooling sequence):\\n # ADM Gabs > 5\\n # ADM Gabs > 5.93 + 5.047(Bp-Rp)\\n # ADM Gabs > 6(Bp-Rp)3 - 21.77(Bp-Rp)2 + 27.91(Bp-Rp) + 0.897\\n # ADM Bp-Rp < 1.7\\n Gabs = gaiagmag+5.*np.log10(parallax.clip(1e-16))-10.\\n br = gaiabmag - gaiarmag\\n mws &= Gabs > 5.\\n mws &= Gabs > 5.93 + 5.047*br\\n mws &= Gabs > 6*br*br*br - 21.77*br*br + 27.91*br + 0.897\\n mws &= br < 1.7\\n\\n # ADM Finite proper motion to reject quasars\\n # ADM Inexplicably I'm getting a Runtimewarning here for\\n # ADM a few values in the sqrt, so I'm catching it\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n pm = np.sqrt(pmra**2. + pmdec**2.)\\n mws &= pm > 2.\\n\\n # ADM As of DR7, photbprpexcessfactor and astrometricsigma5dmax are not in the\\n # ADM imaging catalogs. Until they are, ignore these cuts\\n if photbprpexcessfactor is not None:\\n # ADM remove problem objects, which often have bad astrometry\\n mws &= photbprpexcessfactor < 1.7 + 0.06*br*br\\n\\n if astrometricsigma5dmax is not None:\\n # ADM Reject white dwarfs that have really poor astrometry while\\n # ADM retaining white dwarfs that only have relatively poor astrometry\\n mws &= ((astrometricsigma5dmax < 1.5) |\\n ((astrometricexcessnoise < 1.) & (parallaxovererror > 4.) & (pm > 10.)))\\n\\n return mws\",\n \"def test_visualize_wfe_budget():\\n nrc = webbpsf.NIRCam()\\n nrc.visualize_wfe_budget()\",\n \"def evaluate_design(self): # to update the pr object\",\n \"def getVWFile(tsvFile, vwFile, dataIndex, dictionary, tfidf_model, train=True):\\r\\n start = datetime.now()\\r\\n \\r\\n # extract all the index\\r\\n catIndex = dataIndex[\\\"catIndex\\\"]\\r\\n subCatIndex = dataIndex[\\\"subCatIndex\\\"]\\r\\n attrsKeyIndex = dataIndex[\\\"attrsKeyIndex\\\"]\\r\\n attrsValIndex = dataIndex[\\\"attrsValIndex\\\"]\\r\\n wordIndex = dataIndex[\\\"wordIndex\\\"]\\r\\n \\r\\n with open(vwFile, \\\"wb\\\") as vwWriter:\\r\\n with open(tsvFile, \\\"rb\\\") as tsvReader:\\r\\n itemReader = DictReader(tsvReader, delimiter='\\\\t', quotechar='\\\"')\\r\\n for i, item in enumerate(itemReader):\\r\\n item = {featureName:featureValue.decode('utf-8') \\\\\\r\\n for featureName,featureValue in item.items() \\\\\\r\\n if featureValue is not None}\\r\\n\\r\\n # get header\\r\\n itemid = int(item[\\\"itemid\\\"])\\r\\n label = int(item[\\\"is_blocked\\\"]) if train else 1\\r\\n header = \\\"%s '%s \\\" % (int(2*label - 1), itemid)\\r\\n \\r\\n # category\\r\\n categoryFeat = \\\"|C %s \\\" % catIndex[ item[\\\"category\\\"] ]\\r\\n \\r\\n # subcategory\\r\\n subcategoryFeat = \\\"|SC %s \\\" % subCatIndex[ item[\\\"subcategory\\\"] ]\\r\\n \\r\\n # title\\r\\n title = [ str(wordIndex[w]) for w in getWords(item[\\\"title\\\"]) ]\\r\\n # first-gram\\r\\n title_start = title[0] if len(title)>0 else \\\"0\\\"\\r\\n # end-gram\\r\\n title_end = title[-1] if len(title)>0 else \\\"0\\\"\\r\\n # naming is a pain for me\\r\\n titleFeat = \\\"|T %s |bT %s |cT %s \\\" % (\\\" \\\".join(title), title_start, title_end)\\r\\n titleStatsFeat = \\\"|t %s \\\" % getTextStatsFeat(item[\\\"title\\\"])\\r\\n \\r\\n # description\\r\\n description = [ str(wordIndex[w]) for w in getWords(item[\\\"description\\\"]) ]\\r\\n # first-gram\\r\\n description_start = description[0] if len(description)>0 else \\\"0\\\"\\r\\n # end-gram\\r\\n description_end = description[-1] if len(description)>0 else \\\"0\\\"\\r\\n descriptionFeat = \\\"|D %s |fD %s |gD %s \\\" % (\\\" \\\".join(description), description_start, description_end)\\r\\n descriptionStatsFeat = \\\"|d %s \\\" % getTextStatsFeat(item[\\\"description\\\"])\\r\\n tfidf_feat1 = getTfidfFeat(getUnigram(description), dictionary[1], tfidf_model[1])\\r\\n # 2gram tfidf seem to harm the performance, you are save to drop it here\\r\\n tfidf_feat2 = getTfidfFeat(getBigram(description, \\\"_\\\"), dictionary[2], tfidf_model[2])\\r\\n descriptionFeat += \\\"|iD %s |jD %s \\\" % (tfidf_feat1, tfidf_feat2)\\r\\n \\r\\n # attrs\\r\\n attrsFeat = \\\"\\\"\\r\\n countAttrs = 0\\r\\n if \\\"attrs\\\" in item:\\r\\n attrsDict = getAttrsDict(item[\\\"attrs\\\"])\\r\\n #print attrs\\r\\n for k,v in list(attrsDict.items()):\\r\\n countAttrs += 1\\r\\n attrsFeat += \\\"|A%s %s \\\" % (attrsKeyIndex[k], attrsValIndex[v])\\r\\n attrsFeat += \\\"|a \\\"\\r\\n for k,v in list(attrsDict.items()):\\r\\n attrsFeat += \\\"%s \\\" % (attrsKeyIndex[k]) \\r\\n if len(attrsFeat) == 0:\\r\\n attrsFeat = \\\"|NA 1 \\\"\\r\\n attrsFeat += \\\"|hAC %s \\\" % countAttrs\\r\\n \\r\\n # price\\r\\n priceFeat = \\\"|P %s \\\" % item[\\\"price\\\"] \\r\\n # phones_cnt\\r\\n phonesCntFeat = \\\"|p %s \\\" % item[\\\"phones_cnt\\\"]\\r\\n # emails_cnt\\r\\n emailsCntFeat = \\\"|e %s \\\" % item[\\\"emails_cnt\\\"]\\r\\n # urls_cnt\\r\\n urlsCntFeat = \\\"|u %s \\\" % item[\\\"urls_cnt\\\"]\\r\\n \\r\\n # output\\r\\n vwLine = header \\\\\\r\\n + categoryFeat \\\\\\r\\n + subcategoryFeat \\\\\\r\\n + titleFeat \\\\\\r\\n + titleStatsFeat \\\\\\r\\n + descriptionFeat \\\\\\r\\n + descriptionStatsFeat \\\\\\r\\n + attrsFeat \\\\\\r\\n + priceFeat \\\\\\r\\n + phonesCntFeat \\\\\\r\\n + emailsCntFeat \\\\\\r\\n + urlsCntFeat[:-1] + \\\"\\\\n\\\"\\r\\n vwWriter.write( vwLine )\\r\\n \\r\\n # report progress\\r\\n if (i+1)%10000 == 0:\\r\\n print(( \\\"\\\\n%s\\\\t%s\\\"%((i+1),str(datetime.now() - start)) ))\\r\\n print(( \\\"Sample output:\\\\n%s\\\" % vwLine ))\",\n \"def check_wf(self,wf):\\n pass\",\n \"def geocube():\",\n \"def has_wcs(self):\\n return self.wcs is not None\",\n \"def plotrgcloud(self):\\n print self.kpunten\\n for i in range(len(self.kpunten[0])):\\n self.writetext('sen ='+ self.kpunten[0][i][0], (0.65,0.85), axnum = 0, hor = None ,ver = None , rot = None ,fs =14 , transform = self.fig.axes[0].transAxes)\\n if i == len(self.kpunten[0]) -1 :\\n end = None\\n else:\\n end = self.kpunten[0][i+1][1] + 1\\n print end\\n self.plotrgwrap( self.rgindex,2*self.reader.npair+self.rgindex,'real part of rgvars (a.u)' , 'imaginary part of rgvars (a.u.)', tit ='RG vars g = %f all states'%(self.chardata) , begin = self.kpunten[0][i][1] , stop = end , name = 'cpcloud'+ self.kpunten[0][i][0] , filenum = 0)\",\n \"def newWS(self, y):\\n keys=np.array(self.ImageSolution.keys())\\n try:\\n i=abs(keys-y).argmin()\\n ws=self.ImageSolution[keys[i]]\\n nws=WavelengthSolution.WavelengthSolution(ws.x_arr,ws.w_arr, order=ws.order, function=ws.function)\\n nws.fit()\\n return nws\\n except :\\n return self.ws\",\n \"def calc_wvf(pedestrian, key, face, mesh_area,radius): \\n normal = envuo.py3dmodel.construct.make_vector((0,0,0),envuo.py3dmodel.calculate.face_normal(face))\\n surf2ped = envuo.py3dmodel.construct.make_vector(key,pedestrian)\\n sa_ped = 4.0*np.pi*radius**2\\n theta = normal.Angle(surf2ped)\\n h = surf2ped.Magnitude()/radius \\n phi = np.arctan(1/h)\\n threshold = np.pi/2.0 - phi\\n\\n if abs(h*np.cos(theta)) > 1:\\n F = abs(np.cos(theta))/h**2; \\n else:\\n x = np.sqrt(h**2-1)/np.tan(theta) #np.sqrt(h**2-1)\\n y = np.sqrt(1-x**2) #-x/np.tan(theta) #\\n F = (np.pi - abs(np.cos(x)) - x*y*np.tan(theta)**2)*abs(np.cos(theta))/(np.pi*h**2) + np.arctan(y*abs(np.cos(theta))/x)/np.pi; \\n print pedestrian,' passes threshold'\\n return mesh_area*F/sa_ped\",\n \"def compute_RS(W):\\n return None\",\n \"def _vSWVT(self):\\r\\n\\r\\n logStr = \\\"{0:s}.{1:s}: \\\".format(self.__class__.__name__, sys._getframe().f_code.co_name)\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'Start.')) \\r\\n \\r\\n try: \\r\\n vSWVT = None\\r\\n vSWVT=pd.merge(self.dataFrames['SWVT'],self.dataFrames['SWVT_ROWT'],left_on='pk',right_on='fk')\\r\\n vSWVT['ZEIT']=pd.to_numeric(vSWVT['ZEIT']) \\r\\n vSWVT['W']=pd.to_numeric(vSWVT['W']) \\r\\n vSWVT['ZEIT_RANG']=vSWVT.groupby(['pk_x'])['ZEIT'].rank(ascending=True)\\r\\n #\\r\\n vSWVT_g=vSWVT.groupby(['pk_x'], as_index=False).agg({'W':[np.min,np.max]})\\r\\n vSWVT_g.columns= [tup[0]+tup[1] for tup in zip(vSWVT_g.columns.get_level_values(0),vSWVT_g.columns.get_level_values(1))]\\r\\n vSWVT_g.rename(columns={'Wamin':'W_min','Wamax':'W_max'},inplace=True)\\r\\n #\\r\\n vSWVT=pd.merge(vSWVT,vSWVT_g,left_on='pk_x',right_on='pk_x')\\r\\n #\\r\\n vSWVT=vSWVT[vSWVT['ZEIT_RANG']==1]\\r\\n #\\r\\n vSWVT=vSWVT[['NAME','BESCHREIBUNG','INTPOL','ZEITOPTION','W','W_min','W_max','pk_x']]\\r\\n #\\r\\n vSWVT.rename(columns={'pk_x':'pk'},inplace=True)\\r\\n \\r\\n except Exception as e:\\r\\n logStrFinal=\\\"{:s}Exception: Line: {:d}: {!s:s}: {:s}\\\".format(logStr,sys.exc_info()[-1].tb_lineno,type(e),str(e))\\r\\n logger.error(logStrFinal) \\r\\n raise XmError(logStrFinal) \\r\\n finally:\\r\\n logger.debug(\\\"{0:s}{1:s}\\\".format(logStr,'_Done.'))\\r\\n return vSWVT\",\n \"def test_slpi_cwro(self):\\r\\n\\t\\twith open(\\\"test_slpi_cwro.txt\\\", \\\"w\\\") as test_slpi_cwro_output:\\r\\n\\t\\t\\tsys.stdout = test_slpi_cwro_output # Redirect print in censor to temporary output file\\r\\n\\t\\t\\t# Appropriate censor function call\\r\\n\\t\\t\\tcensor(censor_words_file_location, text_file_location, lines_per_iteration=1, censor_words_one_pass=True)\\r\\n\\t\\twith open(\\\"test_slpi_cwro.txt\\\", \\\"r\\\") as test_slpi_cwro_output:\\r\\n\\t\\t\\twhile True:\\r\\n\\t\\t\\t\\t# Assert every output line in file matches the expected output\\r\\n\\t\\t\\t\\tline_output = test_slpi_cwro_output.readline()\\r\\n\\t\\t\\t\\tline_correct = cc_test_prose.readline()\\r\\n\\t\\t\\t\\tself.assertEqual(line_output, line_correct)\\r\\n\\t\\t\\t\\tif line_correct == '': # Stop reading expected output at eof\\r\\n\\t\\t\\t\\t\\tbreak\\r\\n\\t\\tcc_test_prose.seek(0) # Reset read head in expected output file\\r\\n\\t\\tsys.stdout = sys.__stdout__ # Reset stdout redirection\\r\\n\\t\\tos.remove(\\\"test_slpi_cwro.txt\\\") # Delete temporary output file if test is successful\\r\",\n \"def collecte_docs(self, chercheur, overwrite=False): # self,\\n init = overwrite # If True, data persistence is lost when references are updated\\n docs = hal.find_publications(chercheur[\\\"halId_s\\\"], \\\"authIdHal_s\\\")\\n\\n progress_recorder = ProgressRecorder(self)\\n progress_recorder.set_progress(0, len(docs), description=\\\"récupération des données HAL\\\")\\n # Insert documents collection\\n for num, doc in enumerate(docs):\\n doc[\\\"country_colaboration\\\"] = location_docs.generate_countrys_fields(doc)\\n doc = doi_enrichissement.docs_enrichissement_doi(doc)\\n if \\\"fr_abstract_s\\\" in doc.keys():\\n if isinstance(doc[\\\"fr_abstract_s\\\"], list):\\n doc[\\\"fr_abstract_s\\\"] = \\\"/n\\\".join(doc[\\\"fr_abstract_s\\\"])\\n if len(doc[\\\"fr_abstract_s\\\"]) > 100:\\n doc[\\\"fr_entites\\\"] = keyword_enrichissement.return_entities(\\n doc[\\\"fr_abstract_s\\\"], \\\"fr\\\"\\n )\\n doc[\\\"fr_teeft_keywords\\\"] = keyword_enrichissement.keyword_from_teeft(\\n doc[\\\"fr_abstract_s\\\"], \\\"fr\\\"\\n )\\n if \\\"en_abstract_s\\\" in doc.keys():\\n if isinstance(doc[\\\"en_abstract_s\\\"], list):\\n doc[\\\"en_abstract_s\\\"] = \\\"/n\\\".join(doc[\\\"en_abstract_s\\\"])\\n if len(doc[\\\"en_abstract_s\\\"]) > 100:\\n doc[\\\"en_entites\\\"] = keyword_enrichissement.return_entities(\\n doc[\\\"en_abstract_s\\\"], \\\"en\\\"\\n )\\n doc[\\\"en_teeft_keywords\\\"] = keyword_enrichissement.keyword_from_teeft(\\n doc[\\\"en_abstract_s\\\"], \\\"en\\\"\\n )\\n\\n doc[\\\"_id\\\"] = doc[\\\"docid\\\"]\\n doc[\\\"validated\\\"] = True\\n\\n doc[\\\"harvested_from\\\"] = \\\"researcher\\\"\\n\\n doc[\\\"harvested_from_ids\\\"] = []\\n doc[\\\"harvested_from_label\\\"] = []\\n\\n #\\n #\\n # print(doc[\\\"authorship\\\"], doc ['authLastName_s'])\\n\\n if len(doc[\\\"authIdHal_s\\\"]) != len(doc[\\\"authLastName_s\\\"]):\\n # print (\\\"elastichal.py : test d'autorat no good\\\")\\n # test sur le nom complet...\\n nom = [\\n truc\\n for truc in doc[\\\"authLastName_s\\\"]\\n if chercheur[\\\"lastName\\\"].lower() in truc.lower()\\n ] # pour les récemment mariés qui auraient un nom composé...\\n # Après si 'lun des co-auteur porte le même nom...\\n if len(nom) > 0:\\n nom = nom[0].title()\\n try:\\n if doc[\\\"authLastName_s\\\"].index(nom) == 0: # premier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"firstAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n elif (\\n doc[\\\"authLastName_s\\\"].index(nom) == len(doc[\\\"authLastName_s\\\"]) - 1\\n ): # dernier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"lastAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n except ValueError:\\n doc[\\\"authorship\\\"] = []\\n else:\\n doc[\\\"authorship\\\"] = []\\n elif chercheur[\\\"halId_s\\\"] in doc[\\\"authIdHal_s\\\"]:\\n if doc[\\\"authIdHal_s\\\"].index(chercheur[\\\"halId_s\\\"]) == 0:\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"firstAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n elif (\\n doc[\\\"authIdHal_s\\\"].index(chercheur[\\\"halId_s\\\"]) == len(doc[\\\"authIdHal_s\\\"]) - 1\\n ): # dernier\\n doc[\\\"authorship\\\"] = [\\n {\\\"authorship\\\": \\\"lastAuthor\\\", \\\"authIdHal_s\\\": chercheur[\\\"halId_s\\\"]}\\n ]\\n else:\\n doc[\\\"authorship\\\"] = []\\n else:\\n doc[\\\"authorship\\\"] = []\\n\\n doc[\\\"harvested_from_ids\\\"].append(chercheur[\\\"halId_s\\\"])\\n\\n # historique d'appartenance du docId\\n # pour attribuer les bons docs aux chercheurs\\n # harvet_history.append({'docid': doc['docid'], 'from': row['halId_s']})\\n #\\n # for h in harvet_history:\\n # if h['docid'] == doc['docid']:\\n # if h['from'] not in doc[\\\"harvested_from_ids\\\"]:\\n # doc[\\\"harvested_from_ids\\\"].append(h['from'])\\n\\n doc[\\\"records\\\"] = []\\n\\n doc[\\\"MDS\\\"] = utils.calculate_mds(doc)\\n\\n try:\\n should_be_open = utils.should_be_open(doc)\\n if should_be_open == 1:\\n doc[\\\"should_be_open\\\"] = True\\n if should_be_open == -1:\\n doc[\\\"should_be_open\\\"] = False\\n\\n if should_be_open == 1 or should_be_open == 2:\\n doc[\\\"isOaExtra\\\"] = True\\n elif should_be_open == -1:\\n doc[\\\"isOaExtra\\\"] = False\\n except IndexError:\\n print(\\\"publicationDate_tdate error ?\\\")\\n doc[\\\"Created\\\"] = datetime.datetime.now().isoformat()\\n\\n if not init: # récupération de l'existant pour ne pas écraser\\n field = \\\"_id\\\"\\n doc_param = esActions.scope_p(field, doc[\\\"_id\\\"])\\n\\n if not es.indices.exists(\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\"\\n ): # -researchers\\\" + row[\\\"ldapId\\\"] + \\\"-documents\\n print(\\\"exception \\\", chercheur[\\\"labHalId\\\"], chercheur[\\\"ldapId\\\"])\\n\\n res = es.search(\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\",\\n body=doc_param,\\n ) # -researchers\\\" + row[\\\"ldapId\\\"] + \\\"-documents\\n\\n if len(res[\\\"hits\\\"][\\\"hits\\\"]) > 0:\\n doc[\\\"validated\\\"] = res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"validated\\\"]\\n if \\\"authorship\\\" in res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"]:\\n doc[\\\"authorship\\\"] = res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"authorship\\\"]\\n\\n if (\\n res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"modifiedDate_tdate\\\"]\\n != doc[\\\"modifiedDate_tdate\\\"]\\n ):\\n doc[\\\"records\\\"].append(\\n {\\n \\\"beforeModifiedDate_tdate\\\": doc[\\\"modifiedDate_tdate\\\"],\\n \\\"MDS\\\": res[\\\"hits\\\"][\\\"hits\\\"][0][\\\"_source\\\"][\\\"MDS\\\"],\\n }\\n )\\n\\n else:\\n doc[\\\"validated\\\"] = True\\n progress_recorder.set_progress(num, len(docs), description=\\\"(récolte)\\\")\\n progress_recorder.set_progress(num, len(docs), description=\\\"(indexation)\\\")\\n helpers.bulk(\\n es,\\n docs,\\n index=chercheur[\\\"structSirene\\\"]\\n + \\\"-\\\"\\n + chercheur[\\\"labHalId\\\"]\\n + \\\"-researchers-\\\"\\n + chercheur[\\\"ldapId\\\"]\\n + \\\"-documents\\\",\\n refresh=\\\"wait_for\\\",\\n )\\n\\n return chercheur # au cas où\",\n \"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',\\n verbose=False))\\n # No NaNs are supposed to be in the output.\\n self.assertEqual(np.isnan(wv).any(), False)\\n rms1 = rms(rec['wv_250_500_25'], wv[250:500:25])\\n rms2 = rms(rec['wv_750_1000_25'], wv[750:1000:25])\\n self.assertEqual(True, rms1 < 1e-6)\\n self.assertEqual(True, rms2 < 1e-6)\",\n \"def exposedSurf(self):\\n if self.precision:\\n h = self.evaluations.exposedWing.edges[1].point1.x # height of trapezoid\\n B = self.chordRootW # major base of trapezoid\\n b = self.evaluations.chordIntersected.edges[1].length # minor base of trapezoid\\n internalS = 2 * (0.5 * (b + B) * h) # wing surface internal at fuselage\\n return self.surfaceW - internalS\\n else:\\n return self.surfaceW - self.fuselageDiameter * self.cMACW # first guess for a faster evaluation\",\n \"def init_ngrams(self):\\n self.wv.ngrams = {}\\n all_ngrams = []\\n self.wv.syn0 = np.zeros((len(self.wv.vocab), self.vector_size), dtype=REAL)\\n\\n for w, vocab in self.wv.vocab.items():\\n all_ngrams += compute_ngrams(w, self.wv.min_n, self.wv.max_n)\\n self.wv.syn0[vocab.index] += np.array(self.wv.syn0_ngrams[vocab.index])\\n\\n all_ngrams = set(all_ngrams)\\n self.num_ngram_vectors = len(all_ngrams)\\n ngram_indices = []\\n for i, ngram in enumerate(all_ngrams):\\n ngram_hash = ft_hash(ngram)\\n ngram_indices.append(len(self.wv.vocab) + ngram_hash % self.bucket)\\n self.wv.ngrams[ngram] = i\\n self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)\\n\\n ngram_weights = self.wv.syn0_ngrams\\n\\n logger.info(\\n \\\"loading weights for %s words for fastText model from %s\\\",\\n len(self.wv.vocab), self.file_name\\n )\\n\\n for w, vocab in self.wv.vocab.items():\\n word_ngrams = compute_ngrams(w, self.wv.min_n, self.wv.max_n)\\n for word_ngram in word_ngrams:\\n self.wv.syn0[vocab.index] += np.array(ngram_weights[self.wv.ngrams[word_ngram]])\\n\\n self.wv.syn0[vocab.index] /= (len(word_ngrams) + 1)\\n logger.info(\\n \\\"loaded %s weight matrix for fastText model from %s\\\",\\n self.wv.syn0.shape, self.file_name\\n )\",\n \"def stop_word(w): # local feature\\n return (w in swl)\",\n \"def v(w,s):\\n return w\",\n \"def build_vocab(self, corpus):\\n if self.vocabulary_counts != None:\\n logger.debug(\\\"building vocabulary from provided frequency map\\\")\\n vocab = self.vocabulary_counts\\n else:\\n logger.debug(\\\"default vocabulary building\\\")\\n super(Skipgram, self).build_vocab(corpus)\\n return\\n\\n # assign a unique index to each word\\n self.vocab, self.index2word = {}, []\\n\\n for word, count in vocab.iteritems():\\n v = Vocab()\\n v.count = count\\n if v.count >= self.min_count:\\n v.index = len(self.vocab)\\n self.index2word.append(word)\\n self.vocab[word] = v\\n\\n logger.debug(\\\"total %i word types after removing those with count<%s\\\" % (len(self.vocab), self.min_count))\\n\\n if self.hs:\\n # add info about each word's Huffman encoding\\n self.create_binary_tree()\\n if self.negative:\\n # build the table for drawing random words (for negative sampling)\\n self.make_table()\\n # precalculate downsampling thresholds\\n self.precalc_sampling()\\n self.reset_weights()\",\n \"def compare_wavs_length(c_wv, s_wv):\\n\\n # If the style wav is shorter than the content wav, exit in error\\n if s_wv.shape[0] < c_wv.shape[0]:\\n raise WavError(\\\"The style wav must be as long or longer than the content wav\\\")\\n\\n # If the style wav is longer, truncate it to match the content length\\n elif s_wv.shape[0] > c_wv.shape[0]:\\n print(\\\"Truncating style wav to match content wav length\\\")\\n s_wv = np.copy(s_wv[:c_wv.shape[0],:])\\n\\n return s_wv\",\n \"def calc_doc_ret_MAP():\\n \\n# docs_norm_scores_dicts_path = linux_base_path+\\\"/docs_norm_scores_dicts\\\"\\n claim_rel_docno_dict = read_pickle(\\\"claim_rel_docno_dict\\\") #key is clm, value is a set of the relevant docno\\n# nDCG_MAP_res = base_path +\\\"\\\\\\\\nDCG_MAP_res\\\\\\\\\\\"\\n# docs_norms_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\\\\\\\\\"\\n docs_norms_path = linux_base_path+\\\"/docs_norm_scores_dicts/\\\"\\n nDCG_MAP_res = linux_base_path +\\\"/nDCG_MAP_res/\\\"\\n \\n AP_cut_off = 1000\\n k_val = 100\\n p = 10\\n log = open(\\\"calc_doc_avg_nDCG_MAP_log_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),\\\"wb\\\")\\n res_file = open(nDCG_MAP_res+\\\"doc_ret_nDCG_MAP_res_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),\\\"wb\\\")\\n# each_params_AVGnDCG_MAP_dict = {} #key is alpha,beta,k_docs,lambda and val is the avg nDCG and MAP across all claims together\\n each_params_MAP_dict = {}\\n# NDCG_AP_all_claims_all_param_values = {}\\n AP_all_claims_all_param_values = {}\\n best_avg_nDCG = 0\\n best_MAP = 0 #across all claims in a given configuration, find the max measures\\n \\n# docs_norms_path = base_path+\\\"\\\\\\\\docs_norm_scores_dicts\\\\\\\\\\\"\\n claims_dict = read_pickle(\\\"claim_dict\\\")\\n #count the number of sentences that were retrived that are in the true data....sum for each claim, then average.\\n \\n \\n for alpha in range(0,11,1): #change just for test!\\n for beta in range(0,10,1):\\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\\n NDCG_all_claims= {} #key is a claim, value is the nDCG\\n AP_all_claims= {} \\n AP_cut_off = 1000\\n curr_filename = docs_norms_path+\\\"clm_key_ranked_list_of_docs_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)\\n clm_key_ranked_list_of_docs_baseline = read_pickle(curr_filename) #key is qID and docid\\n #need to turn it to a list of docs\\n for clm in claim_list:\\n try:\\n# nDCG_score = utils_linux.calc_doc_emp_NDCG(curr_source,str(clm),clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]],p)\\n# NDCG_all_claims[clm] = nDCG_score\\n AP_score = utils_linux.calc_doc_AP_relevance(AP_cut_off,curr_source,clm,clm_key_ranked_list_of_docs_baseline[clm],claim_rel_docno_dict[claims_dict[str(clm)]])\\n AP_all_claims[clm] = AP_score\\n AP_all_claims_all_param_values[clm,alpha_f,beta_f,k_val] = AP_score\\n except Exception as err: \\n log.write('problem in calculations: in source: '+ curr_source+' in clm '+ claims_dict[str(clm)]+\\\" alpha:\\\"+str(alpha_f)+ \\\"beta:\\\"+str(beta_f)+\\\" \\\\n\\\" ) \\n for arg in err.args:\\n log.write(arg+\\\" \\\") \\n log.write(\\\"\\\\n\\\") \\n# average_NDCG = float(float(sum(NDCG_all_claims.values()))/float(len(NDCG_all_claims))) #across all claims...\\n# if average_NDCG > best_avg_nDCG:\\n# best_avg_nDCG = average_NDCG\\n# best_avg_nDCG_configuration = (alpha_f,beta_f,k_val)\\n MAP = float(float(sum(AP_all_claims.values()))/float(len(AP_all_claims)))\\n if MAP > best_MAP:\\n best_MAP = MAP\\n best_MAP_configuration = (alpha_f,beta_f,k_val)\\n each_params_MAP_dict[alpha_f,beta_f,k_val] = MAP\\n utils_linux.save_pickle(nDCG_MAP_res+\\\"doc_ret_NDCG_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),NDCG_all_claims)\\n utils_linux.save_pickle(nDCG_MAP_res+\\\"doc_ret_AP_all_claims_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val),AP_all_claims)\\n# res_file.write(\\\"alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"|\\\"+\\\"AnDCG_\\\"+str(average_NDCG)+\\\"_MAP_\\\"+str(MAP)+\\\"\\\\n\\\")\\n res_file.write(\\\"alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"|_MAP_\\\"+str(MAP)+\\\"\\\\n\\\")\\n save_pickle(nDCG_MAP_res+\\\"doc_ret_NDCG_AP_all_claims_all_param_values_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),AP_all_claims_all_param_values)\\n save_pickle(nDCG_MAP_res+\\\"doc_ret_each_params_AVGnDCG_MAP_dict_k_top_docs_\\\"+str(k_val)+\\\"_at_\\\"+str(p),each_params_MAP_dict)\\n# best_row = \\\"best_avg_nDCG|\\\"+str(best_avg_nDCG)+\\\"|best_avg_nDCG_configuration|\\\"+str(best_avg_nDCG_configuration[0])+\\\",\\\"+str(best_avg_nDCG_configuration[1])+\\\",\\\"+str(best_avg_nDCG_configuration[3])+\\\",\\\"+str(best_avg_nDCG_configuration[2])+\\\"|\\\"\\n best_row = \\\"best_MAP|\\\" +str(best_MAP)+\\\"|best_MAP_configuration|\\\"+str(best_MAP_configuration[0])+\\\",\\\"+str(best_MAP_configuration[1])+\\\",\\\"+str(best_MAP_configuration[2])\\n res_file.write(best_row)\\n res_file.close()\\n log.close()\",\n \"def documento():\\r\\n\\tpass\",\n \"def qwf(self, vw, ev, gp, psi_l, lai, dt):\\n\\t\\t#if the amount of water in storage is less than amount that will be absorbed by plant in timestep dt, then what's left will be absorbed \\n\\t qw = (self.gwf(self.psi_wf(self.vw,self.d1, self.d1, self.ns, self.tl), self.H, self.J)*(self.psi_wf(self.vw, self.d1, self.d1, self.ns, self.tl) - (ev*(1. - self.F_CAP))/(lai*gp) - psi_l)*lai)\\n\\t if self.vw == 0:\\n\\t return 0.\\n\\t elif self.vw*10**6 <= qw*dt:\\n\\t return (self.vw*10**6/dt)\\n\\t else:\\n\\t return qw\",\n \"def _compute_export_in_woo(self):\\n for rec in self:\\n rec.ks_export_in_woo = bool(rec.ks_woo_id)\",\n \"def test_continue_build() -> None:\\n tknzr = WsTknzr(is_uncased=True, max_vocab=-1, min_count=0)\\n tknzr.build_vocab(['a'])\\n tknzr.build_vocab(['b'])\\n tknzr.build_vocab(['c'])\\n assert tknzr.tk2id == {\\n BOS_TK: BOS_TKID,\\n EOS_TK: EOS_TKID,\\n PAD_TK: PAD_TKID,\\n UNK_TK: UNK_TKID,\\n 'a': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 1,\\n 'b': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 2,\\n 'c': max(BOS_TKID, EOS_TKID, PAD_TKID, UNK_TKID) + 3,\\n }\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def zapisi_pot(pot):\",\n \"def evaluate():\\n global dictionary, wv\\n count = 0\\n # To save the scores by distance and similarity\\n scores = np.zeros(6)\\n similar = np.zeros(6)\\n itr = len(dictionary)\\n logging.info('running evaluation for {0} samples'.format(itr))\\n for key in dictionary:\\n progress = (count / itr) * 100\\n d = dictionary[key].split('resource/')\\n d = [idx.split()[0].translate(table).lower() for idx in d[1:]]\\n try:\\n r = np.array(list(map(lambda x: wv.get_vector(x), d)),\\n dtype=np.float32)\\n except KeyError:\\n itr -= 1\\n continue\\n if np.any(np.isnan(r)):\\n itr -= 1\\n continue\\n else:\\n if r.ndim == 2:\\n try:\\n # Mean of vector containing all word vectors\\n # obtained from abstract.\\n r = r.mean(axis=0).reshape(1, -1)\\n \\n # Obtain the vectors for the entity\\n mean_vec = mean_encoder(dictionary[key])\\n mean_vec = mean_vec.reshape(1, -1) / norm(mean_vec)\\n mean_dist_vec = distance_encoder(dictionary[key])\\n mean_dist_vec = mean_dist_vec.reshape(1, -1)\\n mean_dist_vec = mean_dist_vec / norm(mean_dist_vec)\\n title_vec = title_mean(key)\\n title_vec = title_vec.reshape(1, -1) / norm(title_vec)\\n abstract_vec = abstract_encoder(key)\\n abstract_vec = abstract_vec.reshape(1, -1)\\n abstract_vec = abstract_vec / norm(abstract_vec)\\n random_vec = np.random.randn(100).reshape(1, -1)\\n zero_vec = np.zeros(100).reshape(1, -1)\\n \\n # Score the entity vectors\\n scores[0] += norm(r - mean_vec)\\n scores[1] += norm(r - mean_dist_vec)\\n scores[2] += norm(r - title_vec)\\n scores[3] += norm(r - abstract_vec)\\n scores[4] += norm(r - random_vec)\\n scores[5] += norm(r - zero_vec)\\n similar[0] += cosine_similarity(r, mean_vec)\\n similar[1] += cosine_similarity(r, mean_dist_vec)\\n similar[2] += cosine_similarity(r, title_vec)\\n similar[3] += cosine_similarity(r, abstract_vec)\\n similar[4] += cosine_similarity(r, random_vec)\\n similar[5] += cosine_similarity(r, zero_vec)\\n count += 1\\n print(count, end='\\\\r')\\n except (ValueError, KeyError) as _:\\n itr -= 1\\n continue\\n else:\\n itr -= 1\\n continue\\n # Normalize the scores to get a better\\n # comparison against the baselines.\\n scores = scores / norm(scores)\\n similar = similar / norm(similar)\\n print_summary(scores, similar)\",\n \"def _derW(self, w, x, y, z):\\n if _isscalar(w):\\n w_pos = max(min(self.wSearchFunc(self.w_list, w), self.w_n - 1), 1)\\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\\n else:\\n w_pos = self.wSearchFunc(self.w_list, w)\\n w_pos[w_pos < 1] = 1\\n w_pos[w_pos > self.w_n - 1] = self.w_n - 1\\n x_pos = self.xSearchFunc(self.x_list, x)\\n x_pos[x_pos < 1] = 1\\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\\n y_pos = self.ySearchFunc(self.y_list, y)\\n y_pos[y_pos < 1] = 1\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n z_pos = self.zSearchFunc(self.z_list, z)\\n z_pos[z_pos < 1] = 1\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n i = w_pos # for convenience\\n j = x_pos\\n k = y_pos\\n l = z_pos\\n beta = (x - self.x_list[j - 1]) / (self.x_list[j] - self.x_list[j - 1])\\n gamma = (y - self.y_list[k - 1]) / (self.y_list[k] - self.y_list[k - 1])\\n delta = (z - self.z_list[l - 1]) / (self.z_list[l] - self.z_list[l - 1])\\n dfdw = (\\n (\\n (1 - beta)\\n * (1 - gamma)\\n * (1 - delta)\\n * self.f_values[i, j - 1, k - 1, l - 1]\\n + (1 - beta) * (1 - gamma) * delta * self.f_values[i, j - 1, k - 1, l]\\n + (1 - beta) * gamma * (1 - delta) * self.f_values[i, j - 1, k, l - 1]\\n + (1 - beta) * gamma * delta * self.f_values[i, j - 1, k, l]\\n + beta * (1 - gamma) * (1 - delta) * self.f_values[i, j, k - 1, l - 1]\\n + beta * (1 - gamma) * delta * self.f_values[i, j, k - 1, l]\\n + beta * gamma * (1 - delta) * self.f_values[i, j, k, l - 1]\\n + beta * gamma * delta * self.f_values[i, j, k, l]\\n )\\n - (\\n (1 - beta)\\n * (1 - gamma)\\n * (1 - delta)\\n * self.f_values[i - 1, j - 1, k - 1, l - 1]\\n + (1 - beta)\\n * (1 - gamma)\\n * delta\\n * self.f_values[i - 1, j - 1, k - 1, l]\\n + (1 - beta)\\n * gamma\\n * (1 - delta)\\n * self.f_values[i - 1, j - 1, k, l - 1]\\n + (1 - beta) * gamma * delta * self.f_values[i - 1, j - 1, k, l]\\n + beta\\n * (1 - gamma)\\n * (1 - delta)\\n * self.f_values[i - 1, j, k - 1, l - 1]\\n + beta * (1 - gamma) * delta * self.f_values[i - 1, j, k - 1, l]\\n + beta * gamma * (1 - delta) * self.f_values[i - 1, j, k, l - 1]\\n + beta * gamma * delta * self.f_values[i - 1, j, k, l]\\n )\\n ) / (self.w_list[i] - self.w_list[i - 1])\\n return dfdw\",\n \"def _get_context_from_gdoc(self, key):\\n try:\\n content = self.export_xlsx(key)\\n data = process_xlsx(content)\\n if 'values' in data:\\n data = copy_global_values(data)\\n return data\\n except BadStatusLine:\\n # Stale connection, reset API and data\\n puts(\\\"Connection reset, reloading drive API\\\")\\n self.client = get_drive_api()\\n return self._get_context_from_gdoc(key)\",\n \"def test_validate_wc3(self):\\r\\n assert self.wc2_tree != 0\",\n \"def vwf(self, vw, ev, gp, psi_l, lai, dt):\\n\\t return min(vw - self.qwf(self.vw, self.th, self.gp, self.psi_l, self.LAI, dt)*dt/10.**6, self.ZW)\",\n \"def w(self): # pylint: disable=invalid-name\\n return self._w\",\n \"def processVS(self, model=\\\"okapi\\\", l = 0.5):\\n self.results[model] = {}\\n for query in self.queries:\\n res = {}\\n for doc in query.docs.values():\\n sum_otf = 0.0\\n for term in doc.terms:\\n if model == \\\"okapi\\\":\\n sum_otf += self.okapiTF(term.tf, doc.dlen, self.avgdlen)\\n if model == \\\"tfidf\\\":\\n sum_otf += self.tfidf(term.tf, term.df, doc.dlen, self.avgdlen, self.num_docs)\\n if model == \\\"bm25\\\":\\n sum_otf += self.bm25(term.tf, term.df, query.query_tf[term.term], doc.dlen, self.avgdlen, self.num_docs)\\n res[doc.id] = sum_otf\\n self.results[model][query.id] = res\",\n \"def computeProportionWings(self):\\n self.ws_me_pointsA = []\\n self.ws_me_pointsIy = []\\n self.ws_me_pointsIz = []\\n self.ws_me_pointsJ = []\\n for i in range(self.nWings):\\n wingIndex = i+1\\n wingNnodes = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"FEM\\\"][\\\"nodesFEM\\\"]\\n if self.tigl.wingGetSymmetry(i+1) != 0:\\n wingNnodes = 2*wingNnodes - 1\\n inputMaxA = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"A\\\"]\\n inputMaxIy = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"Iy\\\"]\\n inputMaxIz = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"Iz\\\"]\\n inputMaxJ = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"mechanicalProperties\\\"][\\\"J\\\"]\\n inputInterpolationType = self.settings[\\\"wing\\\"+str(wingIndex)][\\\"FEM\\\"][\\\"mechanicalInterpolationType\\\"]\\n index = np.argmax(self.ws_me_pointsInitArea[i])\\n wingMaxArea = self.ws_me_pointsInitArea[i][index]\\n\\n if inputInterpolationType == \\\"constant\\\":\\n exposant = 0\\n elif inputInterpolationType == \\\"linear\\\":\\n exposant = 1\\n elif inputInterpolationType == \\\"quadratic\\\":\\n exposant = 2\\n else:\\n logger.error(\\\"Wing mechanical properties distribution is\\\")\\n logger.error(\\\"wrong. Accepted values are \\\\\\\"constant\\\\\\\",\\\")\\n logger.error(\\\"\\\\\\\"linear\\\\\\\", \\\\\\\"quadratic\\\\\\\"\\\")\\n sys.exit()\\n\\n coef = np.empty(wingNnodes)\\n self.w_m_pointsA = np.empty(wingNnodes)\\n self.w_m_pointsIy = np.empty(wingNnodes)\\n self.w_m_pointsIz = np.empty(wingNnodes)\\n self.w_m_pointsJ = np.empty(wingNnodes)\\n for j in range(wingNnodes):\\n coef[j] = self.ws_me_pointsInitArea[i][j]/wingMaxArea\\n self.w_m_pointsA[j] = inputMaxA * coef[j]\\n self.w_m_pointsIy[j] = inputMaxIy * coef[j]**exposant\\n self.w_m_pointsIz[j] = inputMaxIz * coef[j]**exposant\\n self.w_m_pointsJ[j] = inputMaxJ * coef[j]**exposant\\n self.ws_me_pointsA.append(self.w_m_pointsA)\\n self.ws_me_pointsIy.append(self.w_m_pointsIy)\\n self.ws_me_pointsIz.append(self.w_m_pointsIz)\\n self.ws_me_pointsJ.append(self.w_m_pointsJ)\",\n \"def unknown(self, w):\\n return True\",\n \"def generate_wordcloud():\\r\\n # \\\"\\\"\\\"Join list into one string\\\"\\\"\\\"\\r\\n # unique_string = (\\\" \\\").join(prioritized)\\r\\n # wc = WordCloud(background_color=\\\"black\\\", width=2000, height=2000,contour_color=\\\"black\\\", max_words=30, relative_scaling=0.5, normalize_plurals=False).generate(unique_string)\\r\\n\\r\\n \\\"\\\"\\\"Generate word cloud based on dictionary\\\"\\\"\\\"\\r\\n wc = WordCloud(background_color=\\\"black\\\", width=2000, height=2000, contour_color=\\\"black\\\", max_words=30,\\r\\n relative_scaling=0.5, normalize_plurals=False).generate_from_frequencies(priority_dict)\\r\\n\\r\\n fig = plt.figure(figsize=(10, 7))\\r\\n fig.suptitle(\\\"Top 30 Most Visited Websites\\\")\\r\\n plt.imshow(wc, interpolation=\\\"bilinear\\\")\\r\\n plt.axis(\\\"on\\\")\\r\\n plt.show()\",\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 w(self):\\n return self._w\",\n \"def filter_w2v_nomenclature(w2vfilename,filter_nomenclature):\\n V = set(filter_nomenclature)\\n wordlist = []\\n veclist = [] \\n istream = open(w2vfilename)\\n istream.readline() #skips w2v header\\n for line in istream:\\n fields = line.split()\\n word = fields[0]\\n if word in V:\\n vec = np.array([float(elt) for elt in fields[1:]])\\n wordlist.append(word)\\n veclist.append(vec)\\n istream.close()\\n M = np.array(veclist)\\n return (wordlist,M)\",\n \"def check_for_correction(dummy_arg):\\n #space_indexes = []\\n #new_space_indexes = []\\n #punct_dict = {}\\n\\n # Get current document and attributes for doc\\n doc = XSCRIPTCONTEXT.getDocument()\\n selection_supplier = doc.getCurrentController()\\n indexAccess = selection_supplier.getSelection()\\n #count = indexAccess.getCount() # don't really need this right now. Only loop once..\\n\\n # get cursor to write corrected word highlighted in blue\\n text = doc.Text\\n vis_cursor = doc.getCurrentController().getViewCursor() # visible cursor in OpenOffice\\n nvis_cursor= vis_cursor.getText().createTextCursorByRange(vis_cursor) # not visible cursor place at same place as visible\\n \\n # set str and txt for use\\n highlighted_txt = indexAccess.getByIndex(0)\\n highlighted_str = highlighted_txt.getString()\\n \\n # strip punctuation from string\\n punctuation = set(string.punctuation)\\n '''\\n for letter in highlighted_str:\\n if letter == ' ':\\n sp_index = highlighted_str.index(letter)\\n space_indexes.append(sp_index + len(space_indexes))\\n highlighted_str = highlighted_str.replace(letter,'',1)\\n \\n for index in space_indexes:\\n highlighted_str = highlighted_str[:index] + ' ' + highlighted_str[index:]\\n\\n \\n for letter in highlighted_str:\\n if letter in punctuation:\\n punc_index = highlighted_str.index(letter)\\n punct_dict[letter] = punc_index\\n highlighted_str = highlighted_str.replace(letter,'',1)\\n '''\\n highlighted_str = ''.join(ch for ch in highlighted_str if ch not in punctuation) \\n highlighted_str_arr = highlighted_str.split()\\n\\n corrected_sent = highlighted_str # correct sentence to be displayed at end\\n\\n # check for correction for each word highlighted\\n for word in highlighted_str_arr:\\n\\n if len(highlighted_str) == 0:\\n return None\\n\\n # call make_correction helper function to correct highlighted word\\n else:\\n correction = make_correction(word)\\n \\n # make sure new correction word is present\\n if correction:\\n # get parent window from document\\n parentwin = doc.CurrentController.Frame.ContainerWindow\\n # make window\\n correction_query_str = word + \\\" => \\\" + correction # show old word => new word\\n prompt = MessageBox(parentwin, correction_query_str, \\\"Correction:\\\", MESSAGEBOX, BUTTONS_YES_NO)\\n \\n # if yes button pressed, replace word\\n if prompt == 2:\\n # replace wrong word with corrected word\\n corrected_sent = corrected_sent.replace(word, correction)\\n '''\\n for letter in corrected_sent:\\n if letter == ' ':\\n sp_index = corrected_sent.index(letter)\\n new_space_indexes.append(sp_index + len(new_space_indexes))\\n corrected_sent = corrected_sent.replace(letter,'',1)\\n \\n for index in new_space_indexes:\\n corrected_sent = corrected_sent[:index] + ' ' + corrected_sent[index:]\\n \\n \\n punc_location = {}\\n for key in punct_dict:\\n p_index = punct_dict[key]\\n for s_index in space_indexes:\\n if abs(p_index-s_index) == 1:\\n location_index = space_indexes.index(s_index)\\n if p_index-s_index > 0:\\n punc_location[key] = new_space_indexes[location_index+1]\\n else:\\n punc_location[key] = new_space_indexes[location_index-1]\\n\\n\\n for key in punc_location:\\n index = punc_location[key]\\n corrected_sent = key\\n #corrected_sent = corrected_sent[:index] + key + corrected_sent[index:]\\n ''' \\n #highlighted_txt.setString(highlighted_str)\\n highlighted_txt.setString(corrected_sent) # replace old word with nothing\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5585714","0.54342604","0.5361827","0.5358429","0.5239973","0.51996017","0.51747024","0.50968176","0.50909096","0.5046365","0.5046365","0.5046365","0.5030739","0.50290895","0.50091815","0.5000712","0.49765882","0.49565095","0.4948263","0.4933547","0.49296203","0.4927025","0.49204654","0.48807576","0.48656607","0.48189992","0.47896227","0.47831023","0.4776721","0.47629702","0.47613952","0.47439992","0.47328347","0.47237265","0.47235972","0.4721873","0.47166127","0.47164702","0.47096157","0.47071394","0.4702857","0.4698241","0.4689027","0.46878487","0.4677702","0.46744296","0.46740288","0.4668247","0.46523455","0.46414217","0.46292722","0.46278188","0.46240953","0.4621931","0.4620553","0.46140903","0.46120727","0.46049476","0.46029636","0.45931628","0.4577626","0.45636553","0.45396805","0.4539332","0.45300084","0.45280063","0.45269606","0.45267335","0.45260525","0.45240107","0.4523979","0.4522597","0.4522522","0.45214245","0.45208898","0.45166287","0.45096076","0.45081404","0.45059565","0.45013678","0.44997627","0.44997627","0.44997627","0.44997627","0.44997627","0.44997627","0.44978","0.4495177","0.44927326","0.4487585","0.44796708","0.44794905","0.44780168","0.4477762","0.44741023","0.44720268","0.44671854","0.44645464","0.44604447","0.44578314"],"string":"[\n \"0.5585714\",\n \"0.54342604\",\n \"0.5361827\",\n \"0.5358429\",\n \"0.5239973\",\n \"0.51996017\",\n \"0.51747024\",\n \"0.50968176\",\n \"0.50909096\",\n \"0.5046365\",\n \"0.5046365\",\n \"0.5046365\",\n \"0.5030739\",\n \"0.50290895\",\n \"0.50091815\",\n \"0.5000712\",\n \"0.49765882\",\n \"0.49565095\",\n \"0.4948263\",\n \"0.4933547\",\n \"0.49296203\",\n \"0.4927025\",\n \"0.49204654\",\n \"0.48807576\",\n \"0.48656607\",\n \"0.48189992\",\n \"0.47896227\",\n \"0.47831023\",\n \"0.4776721\",\n \"0.47629702\",\n \"0.47613952\",\n \"0.47439992\",\n \"0.47328347\",\n \"0.47237265\",\n \"0.47235972\",\n \"0.4721873\",\n \"0.47166127\",\n \"0.47164702\",\n \"0.47096157\",\n \"0.47071394\",\n \"0.4702857\",\n \"0.4698241\",\n \"0.4689027\",\n \"0.46878487\",\n \"0.4677702\",\n \"0.46744296\",\n \"0.46740288\",\n \"0.4668247\",\n \"0.46523455\",\n \"0.46414217\",\n \"0.46292722\",\n \"0.46278188\",\n \"0.46240953\",\n \"0.4621931\",\n \"0.4620553\",\n \"0.46140903\",\n \"0.46120727\",\n \"0.46049476\",\n \"0.46029636\",\n \"0.45931628\",\n \"0.4577626\",\n \"0.45636553\",\n \"0.45396805\",\n \"0.4539332\",\n \"0.45300084\",\n \"0.45280063\",\n \"0.45269606\",\n \"0.45267335\",\n \"0.45260525\",\n \"0.45240107\",\n \"0.4523979\",\n \"0.4522597\",\n \"0.4522522\",\n \"0.45214245\",\n \"0.45208898\",\n \"0.45166287\",\n \"0.45096076\",\n \"0.45081404\",\n \"0.45059565\",\n \"0.45013678\",\n \"0.44997627\",\n \"0.44997627\",\n \"0.44997627\",\n \"0.44997627\",\n \"0.44997627\",\n \"0.44997627\",\n \"0.44978\",\n \"0.4495177\",\n \"0.44927326\",\n \"0.4487585\",\n \"0.44796708\",\n \"0.44794905\",\n \"0.44780168\",\n \"0.4477762\",\n \"0.44741023\",\n \"0.44720268\",\n \"0.44671854\",\n \"0.44645464\",\n \"0.44604447\",\n \"0.44578314\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57827145"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":12899,"cells":{"query":{"kind":"string","value":"master monitor is running or not"},"document":{"kind":"string","value":"def is_running(ssh):\n\tif get_status(ssh) == \"running\":\n\t\treturn True\n\treturn False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __call__(self):\n status = self.os.popen('circusctl status monitor').read().strip()\n\n if status == 'active':\n return True\n elif status == 'stopped':\n return False","def is_master(self):\n return MPControl.is_master","def slave_status():\n run_mysql_command(\"SHOW SLAVE STATUS\\G;\")","def is_monitored(self):\n return self._is_monitored","def is_running(self):\n status = self.get_status_response()\n return ((status[1] & 2) == 2)\n #end is_running()","def check_connection_to_db(self):\n try:\n self._client.admin.command('ismaster')\n return True\n except Exception:\n return False","def am_I_master(self, ipdict):\n hostname = socket.gethostname()\n ip_address = socket.gethostbyname(hostname)\n return ipdict.get(ip_address).is_master","def is_master(self):\n return self._is_master","def is_alive(self):\n if self.status == 1:\n return True\n else:\n return False","def monitor(self):","def start_monitor():\n monitor_enabled = config_json[env]['MONITOR_ENABLED']\n monitor_trigger_interval_s = int( config_json[env]['MONITOR_TRIGGER_INTERVAL_S'] )\n\n # IF SCHEDULE IS ENABLED IN CONFIG:\n if monitor_enabled == \"1\":\n\n print(\"\\nSpace Weather Service Monitor: ENABLED (running every %s seconds)\" % monitor_trigger_interval_s)\n\n # RUN INITIAL CHECK SPACE WEATHER\n processes.process_check_space_weather()\n\n # CREATE SCHEDULER W/ INTERVAL TRIGGER AND START\n scheduler = BackgroundScheduler()\n scheduler.add_job(\n func = processes.process_check_space_weather,\n trigger = IntervalTrigger( seconds = monitor_trigger_interval_s ),\n id = 'check_space_weather',\n name = 'Checking Space Weather Every 30 Seconds')\n scheduler.start()\n atexit.register( lambda: scheduler.shutdown() )\n else:\n print(\"\\nSpace Weather Service Monitor: DISABLED\")","def active_failover_detect_hosts(self):\n self.check_that_instance_is_alive()\n # this is the way to detect the master starter...\n lfs = self.get_log_file()\n if lfs.find(\"Just became master\") >= 0:\n self.is_master = True\n else:\n self.is_master = False\n regx = re.compile(r\"Starting resilientsingle on port (\\d*) .*\")\n match = regx.search(lfs)\n if match is None:\n raise Exception(timestamp() + \"Unable to get my host state! \" + self.basedir + \" - \" + lfs)\n\n self.frontend_port = match.groups()[0]","def isstarted():","def is_alive(self):\n return True","def is_alive(self):\n pass","def is_alive(self):","def monitor(self):\n if self.startup():\n time.sleep(0.250)\n self.run()","def is_alive(addr, user):\n return _ssh_master_cmd(addr, user, 'check') == 0","def is_monitor_process_live(pid_file=None):\n try:\n check_windows_service_status(\"AmbariMetricsHostMonitoring\")\n ams_monitor_process_running = True\n except:\n ams_monitor_process_running = False\n return ams_monitor_process_running","def start_monitoring(self):\n pass","def test_status(self):\n with DockerHost('host', dind=False, start_calico=False) as host:\n host.calicoctl(\"status\")","def is_running(self):\n\t\treturn self in _running","def check_gpsync_running(options):\n \n return gp.getSyncmasterPID('localhost', options.master_data_dir) > 0","def _detect(self):\n if monasca_setup.detection.find_process_cmdline('rabbitmq-server') is not None:\n self.available = True","def health_ok(self):\n for client in self.clients():\n if client.run_cmd('ls'):\n log.info('Vmware cluster is up.')\n return True\n else:\n return False","def is_master(self) -> bool:\n return self.zone.SharedRoomID and self.zone.MasterMode","def is_running(self):\n\t\treturn self._running","def is_host_on(self):\n status = False\n cmd = \"/usr/local/bin/wedge_power.sh status\"\n data = run_shell_cmd(cmd)\n Logger.info(\"[FSCD Testing] Executing cmd= [{}]\".format(cmd))\n Logger.info(\"[FSCD Testing] Received data= [{}]\".format(data))\n if \"on\" in data:\n status = True\n Logger.info(\"[FSCD Testing] userver power status {}\".format(status))\n return status","def owserver_running():\n for proc in psutil.process_iter():\n if 'owserver' in proc.name():\n return True\n return False","def is_sm_running() -> bool:\n initd = '/etc/init.d'\n print(\"Checking SUSE Manager running...\")\n\n # Get tomcat\n tomcat = \"\"\n for cmd in os.listdir(initd):\n if cmd.startswith('tomcat'):\n tomcat = initd + \"/\" + cmd\n break\n\n return os.popen(tomcat + \" status 2>&1\").read().strip().find('dead') == -1","def status(self):\n # process running ?\n pid = self.get_pidfile()\n \n running = True\n \n # process is not running\n if pid is None:\n running = False\n else:\n if not self.send_signal(pid,0):\n running = False\n # abnormal state, delete the file\n self.delete_pidfile()\n \n if running:\n message = \"server is running\\n\"\n else:\n message = \"server is not running\\n\"\n sys.stdout.write(message)\n \n return running","def isPowerMaster(self) -> bool:\r\n if self.visprotocol is not None:\r\n return self.visprotocol.isPowerMaster()\r\n return False","def check_heartbeat(self):\n return True","def running(self):\n\t\treturn self._start is not None","def is_running(self) -> bool:\n return False","def IsStarted(self) :\n\t\t...","def is_running(self):\n\n command = ('ssh {0} -q -o StrictHostKeyChecking=no -o '\n 'UserKnownHostsFile=/dev/null \"pgrep httperf \"').format(self.client)\n\n if subprocess.call(command, stdout=subprocess.PIPE, shell=True) == 0:\n return True\n else:\n return False","def is_running(self):\n return self.running","def is_running(self):\n return self.running","def is_running(self):\n return self.running","def _checkTorcsServer(self):\n isRunning = False\n if self.torcsServerProcess is not None:\n if self.torcsServerProcess.poll() is None:\n isRunning = True\n return isRunning","def _ServerIsRunning( self ):\n return utils.ProcessIsRunning( self._gocode_handle )","def is_master(self, process_group: ProcessGroup = None) -> bool:\n rank = dist.get_rank(group=process_group)\n return rank == 0","def is_running_manager(self) -> bool:\n return self.get_value(self._manager_running_attribute) == '1'","def isRunning(self):\n if not self.hasBeenStarted():\n return False\n \n if not self._slave_dhcp_client_proc.poll(): # Poll our direct child (sudo)\n return False\n \n for pid in self._all_processes_pid:\n if not self._checkPid(pid):\n return False\n \n return True","def isup(self):\n if self.cloudserver:\n # print self.cloudserver.status\n if self.cloudserver.status in (\"ACTIVE\",):\n return True\n \n return False","def is_active(self):\n group_names = self.get_var(\"group_names\", default=[])\n master_or_node = 'oo_masters_to_config' in group_names or 'oo_nodes_to_config' in group_names\n return super(OvsVersion, self).is_active() and master_or_node","def isMaster(self):\n logger.debug(\"Checking if %s is Cloudera Master\" % self)\n is_master = self.getClusterRole()\n logger.debug(\"Is %s master: %s\" % (self, is_master))\n return is_master","def slaveConnected(slaveName):","def running(self):\n return self.sub_process and self.sub_process.is_alive()","async def monitor():\n\n for n in range(6):\n await asyncio.sleep(2)\n print(\"monitor status:\", n, await ps.status())","def monitoring_enabled(self) -> bool:\n return pulumi.get(self, \"monitoring_enabled\")","def __call__(self):\n status = self.os.popen('circusctl status validator').read().strip()\n\n if status == 'active':\n return True\n elif status == 'stopped':\n return False","def is_on(self):\n return self.state == WORKING_STATE","def is_on(self):\n return self.state == WORKING_STATE","def is_on(self):\n return self.state == WORKING_STATE","def _centec_manager_monitor(self, args):\n daemon = CentecDaemon(CentecTorMechanismDriver.pid_file,\n CentecTorMechanismDriver.centec_manger_name)\n if daemon.is_running():\n pass\n else:\n LOG.error(_(\"Centec manager is not running, restarting ...\"))\n self.run_centec_manager(args)","def remote_status():","def get_status(self) -> bool:\n try:\n self.__driver.service.assert_process_still_running()\n return True\n except AttributeError:\n return False","def is_geth_running(self) -> bool:\r\n command = 'docker exec -t %s geth attach ipc://root/abc/geth.ipc --exec \"admin.nodeInfo\"' % self.name\r\n result = self.ip.exec_command(command)\r\n return False if result.split(':')[0] == 'Fatal' else True","def _engineServicesRunning():\n process = subprocess.Popen([\"ps\", \"aux\"], stdout=subprocess.PIPE)\n\n stdout = process.communicate()[0]\n result = process.returncode\n if result != 0:\n raise RuntimeError(\"Unable to check for running client job manager\")\n\n # See if the CJM is running\n running = False\n for line in stdout.split(\"\\n\"):\n if \"python\" in line and \"clientjobmanager.client_job_manager\" in line:\n running = True\n break\n\n return running","def is_running(self):\n qstat = self._grep_qstat('running')\n if qstat:\n return True\n return False","def is_alive(self):\n if (self._s.fileno()>0 and self._running and self._listen):\n return True\n else:\n return False","def running(self) -> bool:","def isconnected(self) -> bool:","def status(self):\n try:\n if not os.path.exists( self.pidfile ): raise Exception(\"pid not exist\")\n pid = int( file_content_get(self.pidfile).strip() )\n except Exception as e:\n pid = None\n\n if not pid:\n sys.stdout.write(\"%s is not running...\\n\"%self.name)\n else:\n sys.stdout.write(\"%s is running with pid %s...\\n\"%(self.name,pid) )\n\n \n return # not an error in a restart","def _isrunning(self):\n return self.dp.state()==PyTango.DevState.RUNNING","def matchLaunch(self):\n self.logQ.put('Success: Display Metrics match')\n #self.logQ.put('Starting GSDMC & GSDM... ')\n if self.startup_flag == True:\n if self.slave_unit == False:\n self.startGsdmc()\n self.startup_flag = False\n if self.system_awake:\n self.startGsdm()","def is_running(self):\n return self._is_running","def is_running(self):\n return self._is_running","def is_active(self):\n with settings(hide('running', 'stdout', 'stderr', 'warnings'), warn_only=True):\n return self._action('is-active').succeeded","def is_running(self):\n status = self._call_player_proxy('GetStatus', None).unpack()[0]\n if status[3] == 1:\n return True\n return False","def _check_master_tablet(self, t, port=None):\n ti = utils.run_vtctl_json(['GetTablet', t.tablet_alias])\n self.assertEqual(ti['type'], topodata_pb2.MASTER)\n if port:\n self.assertEqual(ti['port_map']['vt'], port)\n\n # make sure the health stream is updated\n health = utils.run_vtctl_json(['VtTabletStreamHealth', '-count', '1',\n t.tablet_alias])\n self.assertIn('serving', health)\n self.assertEqual(health['target']['tablet_type'], topodata_pb2.MASTER)","def is_connected(self) -> bool:\n\n return self.send(self.cmd.GET_SYSTEMLINE) == self.cmd.DEFAULT_SYSTEM_LINE","def is_running(self):\n data = self._poll()\n return data.get('building', False)","def monitored(self):\n return self.monitor","def active_failover_detect_host_now_follower(self):\n self.check_that_instance_is_alive()\n lfs = self.get_log_file()\n if lfs.find(\"resilientsingle up and running as follower\") >= 0:\n self.is_master = False\n return True\n return False","def is_master(self): \n\n master_access = (PermissionGroups.query\n .filter_by(group_name=\"Master\")\n .first())\n if self.has_auth_access(master_access):\n return True\n else:\n return False","def status_check(self):\n try:\n client = self.connect()\n client.sys.is_initialized() # make an actual network connection\n return True\n except:\n return False","def monitor(bot):\n\n timestamp = datetime.now()\n \n # If the monitor status file exists, clubroom is open.\n if os.path.exists(STATUSFILE):\n if not get_state():\n print(timestamp.strftime(\"[%d %b, %H:%M]\") + \" -- Open!\")\n set_state(OPEN)\n \n # Randomly choose and send alert message to channel\n alert = ALERT[random.randint(0, len(ALERTS) - 1)]\n for channel in bot.channels:\n bot.msg(channel, alert)\n else:\n if get_state():\n print(timestamp.strftime(\"[%d %b, %H:%M]\") + \" -- Closed!\")\n for channel in bot.channels:\n bot.msg(channel, \"Activity ended.\"))\n clear_topic()\n set_state(CLOSED)\n update_report(\"\", \"\", \"\")","def monitor(instance=\"default\"):\n global logger_ic\n while True:\n try:\n with open(\"{}/{}/.{}-bmc.pid\".format(\n config.infrasim_home, instance, instance), \"r\") as f:\n pid = f.readline().strip()\n if not os.path.exists(\"/proc/{}\".format(pid)):\n logger_ic.warning(\"Node {} vBMC {} is not running, \"\n \"ipmi-console is ready to quit\".\n format(instance, pid))\n break\n time.sleep(3)\n except IOError:\n logger_ic.warning(\"Node {} workspace is possibly destroyed, \"\n \"ipmi-console is ready to quit\".format(instance))\n break\n stop(instance)","def status(server: str):\n\n if isUp(server):\n log.info(f'{server} is running.')\n else:\n log.info(f'{server} is not running.')","def check(self):\n self.lastcheck = time.time()\n delta = time.time() - self.last\n if delta > 270:\n self.server.restart = True\n self.server.connected = False\n elif delta > 180:\n self.server.printer.raw_message(\"PING :♥\")","def is_alive():\n\n ## ---------------------------------------------------------------\n \n cmd = dict()\n cmd[\"type_\"] = \"is_alive\"\n cmd[\"name_\"] = \"\"\n\n s = socket.socket(\n socket.AF_INET,\n socket.SOCK_STREAM\n )\n try:\n s.connect((getml.host, getml.port))\n except ConnectionRefusedError:\n return False\n\n comm.send_string(s, json.dumps(cmd))\n\n s.close()\n\n return True","def is_active():\n return True","def is_alive(self):\n return (self.read_name() != '')","def status(self):\n if self._pid_file_exists() and self._is_running():\n print('DAEMON RUNNING -- pid: {}'.format(self.pid)) \n\n if self._pid_file_exists() and not self._is_running():\n print('DAEMON NOT RUNNiNG -- pid_file exists: {}'.format(self.pid_file))\n\n if not self._pid_file_exists():\n print('DAEMON NOT RUNNING -- No pid_file: {}'.format(self.pid_file))","def _is_running(self):\n # Public interface is given by get_status instead.\n self._update()\n return True if self.running_mode else False","def is_running(self) -> bool:\n return self.executor.is_alive() if self.executor else False","def status(self):\n self.scion_sh('status')","def monitor(self):\n import curses\n import inspect\n\n stdscr = curses.initscr()\n curses.curs_set(0)\n curses.noecho()\n curses.cbreak()\n width_split = curses.COLS//3-1\n win_done = curses.newwin(curses.LINES-1, width_split, 0, 0)\n win_running = curses.newwin(curses.LINES-1, width_split,\n 0, width_split+1)\n win_pending = curses.newwin(curses.LINES-1, width_split,\n 0, 2*width_split+1)\n stdscr.addstr(curses.LINES-1, 0,\n 'Monitoring started. Press Ctrl+C to stop.')\n stdscr.refresh()\n win_done.addstr(0, 0, 'DONE')\n win_pending.addstr(0, 0, 'PENDING')\n while True:\n try:\n win_done.addstr(1, 0,\n f'{len(self.done)} jobs done')\n list_done = list(self.done)[:curses.LINES-3]\n for idx, fut in enumerate(list_done, start=2):\n fmt_str = f'{id(fut):x} {fut._state}'\n win_done.addstr(idx, 0, fmt_str)\n win_done.refresh()\n\n win_running.clear()\n win_running.addstr(0, 0, 'RUNNING')\n win_running.addstr(1, 0,\n f'{self.running.qsize()} jobs running')\n list_running = list(self.running.items())[:curses.LINES-3]\n for idx, (fut, coro) in enumerate(list_running, start=2):\n coro_state = inspect.getcoroutinestate(coro)\n fmt_str = f'{id(fut):x} {coro_state}'\n win_running.addstr(idx, 0, fmt_str)\n win_running.refresh()\n\n win_pending.clrtoeol()\n win_pending.addstr(1, 0,\n f'{self.pending.qsize()} jobs pending')\n win_pending.refresh()\n time.sleep(.1)\n except KeyboardInterrupt:\n break\n\n curses.nocbreak()\n curses.echo()\n curses.endwin()","def get_status(self):\n if self.status:\n print(f\"Server '{self.server_name}' is online\")\n else:\n print(f\"Server '{self.server_name}' is offline\")","def is_running(self) -> bool:\r\n return self.__running","def alive(self):\n return self._proc is not None and self._proc.poll() is None","def check_that_instance_is_alive(self):\n if not self.instance.is_running():\n raise Exception(f\"Starter instance is not running. Base directory: {str(self.basedir)}\")\n if self.instance.status() == psutil.STATUS_ZOMBIE:\n raise Exception(f\"Starter instance is a zombie. Base directory: {str(self.basedir)}\")","def test_interaction_on_master(self, admin_remote):\n timeout = 1 # minute\n sleep_between_restart = 1 # minute\n\n # Stop rabbit and check that there are no errors in output\n self.control_rabbit_service(admin_remote, 'stop')\n\n # Wait till rabbitmq-server has \"Status: \"Exited.\"\" string\n self.wait_rabbit_became_exited(admin_remote, timeout)\n sleep(60 * sleep_between_restart)\n\n # Rabbit start-stops with check that there are no errors in output\n for i in range(5):\n self.control_rabbit_service(admin_remote, 'start')\n sleep(60 * sleep_between_restart)\n self.control_rabbit_service(admin_remote, 'stop')\n\n # Wait till rabbitmq-server has \"Active: active (running)\" string\n self.control_rabbit_service(admin_remote, 'start')\n self.wait_rabbit_became_active(admin_remote, timeout)","def _is_working():\n global _worker\n return _worker is not None and _worker.is_alive()","def connect_to_master():","def is_monitored(self, is_monitored):\n \n self._is_monitored = is_monitored","def check_yarn_service(master, ec2_opts, num_nodes):\n output = spark_ec2.ssh_read(master, ec2_opts, \"/root/ephemeral-hdfs/bin/yarn node -list -all |grep RUNNING |wc -l\")\n # Ok if one slave is down\n return int(output) >= int(num_nodes) - 1"],"string":"[\n \"def __call__(self):\\n status = self.os.popen('circusctl status monitor').read().strip()\\n\\n if status == 'active':\\n return True\\n elif status == 'stopped':\\n return False\",\n \"def is_master(self):\\n return MPControl.is_master\",\n \"def slave_status():\\n run_mysql_command(\\\"SHOW SLAVE STATUS\\\\G;\\\")\",\n \"def is_monitored(self):\\n return self._is_monitored\",\n \"def is_running(self):\\n status = self.get_status_response()\\n return ((status[1] & 2) == 2)\\n #end is_running()\",\n \"def check_connection_to_db(self):\\n try:\\n self._client.admin.command('ismaster')\\n return True\\n except Exception:\\n return False\",\n \"def am_I_master(self, ipdict):\\n hostname = socket.gethostname()\\n ip_address = socket.gethostbyname(hostname)\\n return ipdict.get(ip_address).is_master\",\n \"def is_master(self):\\n return self._is_master\",\n \"def is_alive(self):\\n if self.status == 1:\\n return True\\n else:\\n return False\",\n \"def monitor(self):\",\n \"def start_monitor():\\n monitor_enabled = config_json[env]['MONITOR_ENABLED']\\n monitor_trigger_interval_s = int( config_json[env]['MONITOR_TRIGGER_INTERVAL_S'] )\\n\\n # IF SCHEDULE IS ENABLED IN CONFIG:\\n if monitor_enabled == \\\"1\\\":\\n\\n print(\\\"\\\\nSpace Weather Service Monitor: ENABLED (running every %s seconds)\\\" % monitor_trigger_interval_s)\\n\\n # RUN INITIAL CHECK SPACE WEATHER\\n processes.process_check_space_weather()\\n\\n # CREATE SCHEDULER W/ INTERVAL TRIGGER AND START\\n scheduler = BackgroundScheduler()\\n scheduler.add_job(\\n func = processes.process_check_space_weather,\\n trigger = IntervalTrigger( seconds = monitor_trigger_interval_s ),\\n id = 'check_space_weather',\\n name = 'Checking Space Weather Every 30 Seconds')\\n scheduler.start()\\n atexit.register( lambda: scheduler.shutdown() )\\n else:\\n print(\\\"\\\\nSpace Weather Service Monitor: DISABLED\\\")\",\n \"def active_failover_detect_hosts(self):\\n self.check_that_instance_is_alive()\\n # this is the way to detect the master starter...\\n lfs = self.get_log_file()\\n if lfs.find(\\\"Just became master\\\") >= 0:\\n self.is_master = True\\n else:\\n self.is_master = False\\n regx = re.compile(r\\\"Starting resilientsingle on port (\\\\d*) .*\\\")\\n match = regx.search(lfs)\\n if match is None:\\n raise Exception(timestamp() + \\\"Unable to get my host state! \\\" + self.basedir + \\\" - \\\" + lfs)\\n\\n self.frontend_port = match.groups()[0]\",\n \"def isstarted():\",\n \"def is_alive(self):\\n return True\",\n \"def is_alive(self):\\n pass\",\n \"def is_alive(self):\",\n \"def monitor(self):\\n if self.startup():\\n time.sleep(0.250)\\n self.run()\",\n \"def is_alive(addr, user):\\n return _ssh_master_cmd(addr, user, 'check') == 0\",\n \"def is_monitor_process_live(pid_file=None):\\n try:\\n check_windows_service_status(\\\"AmbariMetricsHostMonitoring\\\")\\n ams_monitor_process_running = True\\n except:\\n ams_monitor_process_running = False\\n return ams_monitor_process_running\",\n \"def start_monitoring(self):\\n pass\",\n \"def test_status(self):\\n with DockerHost('host', dind=False, start_calico=False) as host:\\n host.calicoctl(\\\"status\\\")\",\n \"def is_running(self):\\n\\t\\treturn self in _running\",\n \"def check_gpsync_running(options):\\n \\n return gp.getSyncmasterPID('localhost', options.master_data_dir) > 0\",\n \"def _detect(self):\\n if monasca_setup.detection.find_process_cmdline('rabbitmq-server') is not None:\\n self.available = True\",\n \"def health_ok(self):\\n for client in self.clients():\\n if client.run_cmd('ls'):\\n log.info('Vmware cluster is up.')\\n return True\\n else:\\n return False\",\n \"def is_master(self) -> bool:\\n return self.zone.SharedRoomID and self.zone.MasterMode\",\n \"def is_running(self):\\n\\t\\treturn self._running\",\n \"def is_host_on(self):\\n status = False\\n cmd = \\\"/usr/local/bin/wedge_power.sh status\\\"\\n data = run_shell_cmd(cmd)\\n Logger.info(\\\"[FSCD Testing] Executing cmd= [{}]\\\".format(cmd))\\n Logger.info(\\\"[FSCD Testing] Received data= [{}]\\\".format(data))\\n if \\\"on\\\" in data:\\n status = True\\n Logger.info(\\\"[FSCD Testing] userver power status {}\\\".format(status))\\n return status\",\n \"def owserver_running():\\n for proc in psutil.process_iter():\\n if 'owserver' in proc.name():\\n return True\\n return False\",\n \"def is_sm_running() -> bool:\\n initd = '/etc/init.d'\\n print(\\\"Checking SUSE Manager running...\\\")\\n\\n # Get tomcat\\n tomcat = \\\"\\\"\\n for cmd in os.listdir(initd):\\n if cmd.startswith('tomcat'):\\n tomcat = initd + \\\"/\\\" + cmd\\n break\\n\\n return os.popen(tomcat + \\\" status 2>&1\\\").read().strip().find('dead') == -1\",\n \"def status(self):\\n # process running ?\\n pid = self.get_pidfile()\\n \\n running = True\\n \\n # process is not running\\n if pid is None:\\n running = False\\n else:\\n if not self.send_signal(pid,0):\\n running = False\\n # abnormal state, delete the file\\n self.delete_pidfile()\\n \\n if running:\\n message = \\\"server is running\\\\n\\\"\\n else:\\n message = \\\"server is not running\\\\n\\\"\\n sys.stdout.write(message)\\n \\n return running\",\n \"def isPowerMaster(self) -> bool:\\r\\n if self.visprotocol is not None:\\r\\n return self.visprotocol.isPowerMaster()\\r\\n return False\",\n \"def check_heartbeat(self):\\n return True\",\n \"def running(self):\\n\\t\\treturn self._start is not None\",\n \"def is_running(self) -> bool:\\n return False\",\n \"def IsStarted(self) :\\n\\t\\t...\",\n \"def is_running(self):\\n\\n command = ('ssh {0} -q -o StrictHostKeyChecking=no -o '\\n 'UserKnownHostsFile=/dev/null \\\"pgrep httperf \\\"').format(self.client)\\n\\n if subprocess.call(command, stdout=subprocess.PIPE, shell=True) == 0:\\n return True\\n else:\\n return False\",\n \"def is_running(self):\\n return self.running\",\n \"def is_running(self):\\n return self.running\",\n \"def is_running(self):\\n return self.running\",\n \"def _checkTorcsServer(self):\\n isRunning = False\\n if self.torcsServerProcess is not None:\\n if self.torcsServerProcess.poll() is None:\\n isRunning = True\\n return isRunning\",\n \"def _ServerIsRunning( self ):\\n return utils.ProcessIsRunning( self._gocode_handle )\",\n \"def is_master(self, process_group: ProcessGroup = None) -> bool:\\n rank = dist.get_rank(group=process_group)\\n return rank == 0\",\n \"def is_running_manager(self) -> bool:\\n return self.get_value(self._manager_running_attribute) == '1'\",\n \"def isRunning(self):\\n if not self.hasBeenStarted():\\n return False\\n \\n if not self._slave_dhcp_client_proc.poll(): # Poll our direct child (sudo)\\n return False\\n \\n for pid in self._all_processes_pid:\\n if not self._checkPid(pid):\\n return False\\n \\n return True\",\n \"def isup(self):\\n if self.cloudserver:\\n # print self.cloudserver.status\\n if self.cloudserver.status in (\\\"ACTIVE\\\",):\\n return True\\n \\n return False\",\n \"def is_active(self):\\n group_names = self.get_var(\\\"group_names\\\", default=[])\\n master_or_node = 'oo_masters_to_config' in group_names or 'oo_nodes_to_config' in group_names\\n return super(OvsVersion, self).is_active() and master_or_node\",\n \"def isMaster(self):\\n logger.debug(\\\"Checking if %s is Cloudera Master\\\" % self)\\n is_master = self.getClusterRole()\\n logger.debug(\\\"Is %s master: %s\\\" % (self, is_master))\\n return is_master\",\n \"def slaveConnected(slaveName):\",\n \"def running(self):\\n return self.sub_process and self.sub_process.is_alive()\",\n \"async def monitor():\\n\\n for n in range(6):\\n await asyncio.sleep(2)\\n print(\\\"monitor status:\\\", n, await ps.status())\",\n \"def monitoring_enabled(self) -> bool:\\n return pulumi.get(self, \\\"monitoring_enabled\\\")\",\n \"def __call__(self):\\n status = self.os.popen('circusctl status validator').read().strip()\\n\\n if status == 'active':\\n return True\\n elif status == 'stopped':\\n return False\",\n \"def is_on(self):\\n return self.state == WORKING_STATE\",\n \"def is_on(self):\\n return self.state == WORKING_STATE\",\n \"def is_on(self):\\n return self.state == WORKING_STATE\",\n \"def _centec_manager_monitor(self, args):\\n daemon = CentecDaemon(CentecTorMechanismDriver.pid_file,\\n CentecTorMechanismDriver.centec_manger_name)\\n if daemon.is_running():\\n pass\\n else:\\n LOG.error(_(\\\"Centec manager is not running, restarting ...\\\"))\\n self.run_centec_manager(args)\",\n \"def remote_status():\",\n \"def get_status(self) -> bool:\\n try:\\n self.__driver.service.assert_process_still_running()\\n return True\\n except AttributeError:\\n return False\",\n \"def is_geth_running(self) -> bool:\\r\\n command = 'docker exec -t %s geth attach ipc://root/abc/geth.ipc --exec \\\"admin.nodeInfo\\\"' % self.name\\r\\n result = self.ip.exec_command(command)\\r\\n return False if result.split(':')[0] == 'Fatal' else True\",\n \"def _engineServicesRunning():\\n process = subprocess.Popen([\\\"ps\\\", \\\"aux\\\"], stdout=subprocess.PIPE)\\n\\n stdout = process.communicate()[0]\\n result = process.returncode\\n if result != 0:\\n raise RuntimeError(\\\"Unable to check for running client job manager\\\")\\n\\n # See if the CJM is running\\n running = False\\n for line in stdout.split(\\\"\\\\n\\\"):\\n if \\\"python\\\" in line and \\\"clientjobmanager.client_job_manager\\\" in line:\\n running = True\\n break\\n\\n return running\",\n \"def is_running(self):\\n qstat = self._grep_qstat('running')\\n if qstat:\\n return True\\n return False\",\n \"def is_alive(self):\\n if (self._s.fileno()>0 and self._running and self._listen):\\n return True\\n else:\\n return False\",\n \"def running(self) -> bool:\",\n \"def isconnected(self) -> bool:\",\n \"def status(self):\\n try:\\n if not os.path.exists( self.pidfile ): raise Exception(\\\"pid not exist\\\")\\n pid = int( file_content_get(self.pidfile).strip() )\\n except Exception as e:\\n pid = None\\n\\n if not pid:\\n sys.stdout.write(\\\"%s is not running...\\\\n\\\"%self.name)\\n else:\\n sys.stdout.write(\\\"%s is running with pid %s...\\\\n\\\"%(self.name,pid) )\\n\\n \\n return # not an error in a restart\",\n \"def _isrunning(self):\\n return self.dp.state()==PyTango.DevState.RUNNING\",\n \"def matchLaunch(self):\\n self.logQ.put('Success: Display Metrics match')\\n #self.logQ.put('Starting GSDMC & GSDM... ')\\n if self.startup_flag == True:\\n if self.slave_unit == False:\\n self.startGsdmc()\\n self.startup_flag = False\\n if self.system_awake:\\n self.startGsdm()\",\n \"def is_running(self):\\n return self._is_running\",\n \"def is_running(self):\\n return self._is_running\",\n \"def is_active(self):\\n with settings(hide('running', 'stdout', 'stderr', 'warnings'), warn_only=True):\\n return self._action('is-active').succeeded\",\n \"def is_running(self):\\n status = self._call_player_proxy('GetStatus', None).unpack()[0]\\n if status[3] == 1:\\n return True\\n return False\",\n \"def _check_master_tablet(self, t, port=None):\\n ti = utils.run_vtctl_json(['GetTablet', t.tablet_alias])\\n self.assertEqual(ti['type'], topodata_pb2.MASTER)\\n if port:\\n self.assertEqual(ti['port_map']['vt'], port)\\n\\n # make sure the health stream is updated\\n health = utils.run_vtctl_json(['VtTabletStreamHealth', '-count', '1',\\n t.tablet_alias])\\n self.assertIn('serving', health)\\n self.assertEqual(health['target']['tablet_type'], topodata_pb2.MASTER)\",\n \"def is_connected(self) -> bool:\\n\\n return self.send(self.cmd.GET_SYSTEMLINE) == self.cmd.DEFAULT_SYSTEM_LINE\",\n \"def is_running(self):\\n data = self._poll()\\n return data.get('building', False)\",\n \"def monitored(self):\\n return self.monitor\",\n \"def active_failover_detect_host_now_follower(self):\\n self.check_that_instance_is_alive()\\n lfs = self.get_log_file()\\n if lfs.find(\\\"resilientsingle up and running as follower\\\") >= 0:\\n self.is_master = False\\n return True\\n return False\",\n \"def is_master(self): \\n\\n master_access = (PermissionGroups.query\\n .filter_by(group_name=\\\"Master\\\")\\n .first())\\n if self.has_auth_access(master_access):\\n return True\\n else:\\n return False\",\n \"def status_check(self):\\n try:\\n client = self.connect()\\n client.sys.is_initialized() # make an actual network connection\\n return True\\n except:\\n return False\",\n \"def monitor(bot):\\n\\n timestamp = datetime.now()\\n \\n # If the monitor status file exists, clubroom is open.\\n if os.path.exists(STATUSFILE):\\n if not get_state():\\n print(timestamp.strftime(\\\"[%d %b, %H:%M]\\\") + \\\" -- Open!\\\")\\n set_state(OPEN)\\n \\n # Randomly choose and send alert message to channel\\n alert = ALERT[random.randint(0, len(ALERTS) - 1)]\\n for channel in bot.channels:\\n bot.msg(channel, alert)\\n else:\\n if get_state():\\n print(timestamp.strftime(\\\"[%d %b, %H:%M]\\\") + \\\" -- Closed!\\\")\\n for channel in bot.channels:\\n bot.msg(channel, \\\"Activity ended.\\\"))\\n clear_topic()\\n set_state(CLOSED)\\n update_report(\\\"\\\", \\\"\\\", \\\"\\\")\",\n \"def monitor(instance=\\\"default\\\"):\\n global logger_ic\\n while True:\\n try:\\n with open(\\\"{}/{}/.{}-bmc.pid\\\".format(\\n config.infrasim_home, instance, instance), \\\"r\\\") as f:\\n pid = f.readline().strip()\\n if not os.path.exists(\\\"/proc/{}\\\".format(pid)):\\n logger_ic.warning(\\\"Node {} vBMC {} is not running, \\\"\\n \\\"ipmi-console is ready to quit\\\".\\n format(instance, pid))\\n break\\n time.sleep(3)\\n except IOError:\\n logger_ic.warning(\\\"Node {} workspace is possibly destroyed, \\\"\\n \\\"ipmi-console is ready to quit\\\".format(instance))\\n break\\n stop(instance)\",\n \"def status(server: str):\\n\\n if isUp(server):\\n log.info(f'{server} is running.')\\n else:\\n log.info(f'{server} is not running.')\",\n \"def check(self):\\n self.lastcheck = time.time()\\n delta = time.time() - self.last\\n if delta > 270:\\n self.server.restart = True\\n self.server.connected = False\\n elif delta > 180:\\n self.server.printer.raw_message(\\\"PING :♥\\\")\",\n \"def is_alive():\\n\\n ## ---------------------------------------------------------------\\n \\n cmd = dict()\\n cmd[\\\"type_\\\"] = \\\"is_alive\\\"\\n cmd[\\\"name_\\\"] = \\\"\\\"\\n\\n s = socket.socket(\\n socket.AF_INET,\\n socket.SOCK_STREAM\\n )\\n try:\\n s.connect((getml.host, getml.port))\\n except ConnectionRefusedError:\\n return False\\n\\n comm.send_string(s, json.dumps(cmd))\\n\\n s.close()\\n\\n return True\",\n \"def is_active():\\n return True\",\n \"def is_alive(self):\\n return (self.read_name() != '')\",\n \"def status(self):\\n if self._pid_file_exists() and self._is_running():\\n print('DAEMON RUNNING -- pid: {}'.format(self.pid)) \\n\\n if self._pid_file_exists() and not self._is_running():\\n print('DAEMON NOT RUNNiNG -- pid_file exists: {}'.format(self.pid_file))\\n\\n if not self._pid_file_exists():\\n print('DAEMON NOT RUNNING -- No pid_file: {}'.format(self.pid_file))\",\n \"def _is_running(self):\\n # Public interface is given by get_status instead.\\n self._update()\\n return True if self.running_mode else False\",\n \"def is_running(self) -> bool:\\n return self.executor.is_alive() if self.executor else False\",\n \"def status(self):\\n self.scion_sh('status')\",\n \"def monitor(self):\\n import curses\\n import inspect\\n\\n stdscr = curses.initscr()\\n curses.curs_set(0)\\n curses.noecho()\\n curses.cbreak()\\n width_split = curses.COLS//3-1\\n win_done = curses.newwin(curses.LINES-1, width_split, 0, 0)\\n win_running = curses.newwin(curses.LINES-1, width_split,\\n 0, width_split+1)\\n win_pending = curses.newwin(curses.LINES-1, width_split,\\n 0, 2*width_split+1)\\n stdscr.addstr(curses.LINES-1, 0,\\n 'Monitoring started. Press Ctrl+C to stop.')\\n stdscr.refresh()\\n win_done.addstr(0, 0, 'DONE')\\n win_pending.addstr(0, 0, 'PENDING')\\n while True:\\n try:\\n win_done.addstr(1, 0,\\n f'{len(self.done)} jobs done')\\n list_done = list(self.done)[:curses.LINES-3]\\n for idx, fut in enumerate(list_done, start=2):\\n fmt_str = f'{id(fut):x} {fut._state}'\\n win_done.addstr(idx, 0, fmt_str)\\n win_done.refresh()\\n\\n win_running.clear()\\n win_running.addstr(0, 0, 'RUNNING')\\n win_running.addstr(1, 0,\\n f'{self.running.qsize()} jobs running')\\n list_running = list(self.running.items())[:curses.LINES-3]\\n for idx, (fut, coro) in enumerate(list_running, start=2):\\n coro_state = inspect.getcoroutinestate(coro)\\n fmt_str = f'{id(fut):x} {coro_state}'\\n win_running.addstr(idx, 0, fmt_str)\\n win_running.refresh()\\n\\n win_pending.clrtoeol()\\n win_pending.addstr(1, 0,\\n f'{self.pending.qsize()} jobs pending')\\n win_pending.refresh()\\n time.sleep(.1)\\n except KeyboardInterrupt:\\n break\\n\\n curses.nocbreak()\\n curses.echo()\\n curses.endwin()\",\n \"def get_status(self):\\n if self.status:\\n print(f\\\"Server '{self.server_name}' is online\\\")\\n else:\\n print(f\\\"Server '{self.server_name}' is offline\\\")\",\n \"def is_running(self) -> bool:\\r\\n return self.__running\",\n \"def alive(self):\\n return self._proc is not None and self._proc.poll() is None\",\n \"def check_that_instance_is_alive(self):\\n if not self.instance.is_running():\\n raise Exception(f\\\"Starter instance is not running. Base directory: {str(self.basedir)}\\\")\\n if self.instance.status() == psutil.STATUS_ZOMBIE:\\n raise Exception(f\\\"Starter instance is a zombie. Base directory: {str(self.basedir)}\\\")\",\n \"def test_interaction_on_master(self, admin_remote):\\n timeout = 1 # minute\\n sleep_between_restart = 1 # minute\\n\\n # Stop rabbit and check that there are no errors in output\\n self.control_rabbit_service(admin_remote, 'stop')\\n\\n # Wait till rabbitmq-server has \\\"Status: \\\"Exited.\\\"\\\" string\\n self.wait_rabbit_became_exited(admin_remote, timeout)\\n sleep(60 * sleep_between_restart)\\n\\n # Rabbit start-stops with check that there are no errors in output\\n for i in range(5):\\n self.control_rabbit_service(admin_remote, 'start')\\n sleep(60 * sleep_between_restart)\\n self.control_rabbit_service(admin_remote, 'stop')\\n\\n # Wait till rabbitmq-server has \\\"Active: active (running)\\\" string\\n self.control_rabbit_service(admin_remote, 'start')\\n self.wait_rabbit_became_active(admin_remote, timeout)\",\n \"def _is_working():\\n global _worker\\n return _worker is not None and _worker.is_alive()\",\n \"def connect_to_master():\",\n \"def is_monitored(self, is_monitored):\\n \\n self._is_monitored = is_monitored\",\n \"def check_yarn_service(master, ec2_opts, num_nodes):\\n output = spark_ec2.ssh_read(master, ec2_opts, \\\"/root/ephemeral-hdfs/bin/yarn node -list -all |grep RUNNING |wc -l\\\")\\n # Ok if one slave is down\\n return int(output) >= int(num_nodes) - 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76096","0.71582156","0.69318926","0.68682814","0.67281044","0.6716801","0.669943","0.6669908","0.66140735","0.66064215","0.6597562","0.659302","0.6580973","0.6576386","0.6575719","0.6559207","0.65534914","0.65473324","0.6541179","0.651523","0.64646703","0.6444119","0.6408466","0.63970137","0.6390013","0.6388764","0.637907","0.6364855","0.6346503","0.6338887","0.6315105","0.63072884","0.62968594","0.6293287","0.6280516","0.62765425","0.62723196","0.62719727","0.62719727","0.62719727","0.6271863","0.6258066","0.6256788","0.624756","0.6224249","0.6199905","0.61956924","0.619381","0.6191297","0.619113","0.6185524","0.61758167","0.61478907","0.6131633","0.6131633","0.6131633","0.6126796","0.6123956","0.611456","0.6103716","0.6099456","0.60868704","0.6080606","0.6072585","0.6069966","0.6069018","0.6068805","0.60664177","0.60659957","0.60659957","0.60649306","0.60642517","0.6062837","0.6053333","0.6053167","0.60499763","0.6046977","0.6032638","0.603207","0.6031305","0.6027027","0.6021216","0.6018664","0.6018587","0.6018218","0.6016131","0.60157055","0.6012339","0.6012002","0.60109043","0.6010362","0.600816","0.6008014","0.6007431","0.6004099","0.6003529","0.60034573","0.5998924","0.5996189","0.59918016"],"string":"[\n \"0.76096\",\n \"0.71582156\",\n \"0.69318926\",\n \"0.68682814\",\n \"0.67281044\",\n \"0.6716801\",\n \"0.669943\",\n \"0.6669908\",\n \"0.66140735\",\n \"0.66064215\",\n \"0.6597562\",\n \"0.659302\",\n \"0.6580973\",\n \"0.6576386\",\n \"0.6575719\",\n \"0.6559207\",\n \"0.65534914\",\n \"0.65473324\",\n \"0.6541179\",\n \"0.651523\",\n \"0.64646703\",\n \"0.6444119\",\n \"0.6408466\",\n \"0.63970137\",\n \"0.6390013\",\n \"0.6388764\",\n \"0.637907\",\n \"0.6364855\",\n \"0.6346503\",\n \"0.6338887\",\n \"0.6315105\",\n \"0.63072884\",\n \"0.62968594\",\n \"0.6293287\",\n \"0.6280516\",\n \"0.62765425\",\n \"0.62723196\",\n \"0.62719727\",\n \"0.62719727\",\n \"0.62719727\",\n \"0.6271863\",\n \"0.6258066\",\n \"0.6256788\",\n \"0.624756\",\n \"0.6224249\",\n \"0.6199905\",\n \"0.61956924\",\n \"0.619381\",\n \"0.6191297\",\n \"0.619113\",\n \"0.6185524\",\n \"0.61758167\",\n \"0.61478907\",\n \"0.6131633\",\n \"0.6131633\",\n \"0.6131633\",\n \"0.6126796\",\n \"0.6123956\",\n \"0.611456\",\n \"0.6103716\",\n \"0.6099456\",\n \"0.60868704\",\n \"0.6080606\",\n \"0.6072585\",\n \"0.6069966\",\n \"0.6069018\",\n \"0.6068805\",\n \"0.60664177\",\n \"0.60659957\",\n \"0.60659957\",\n \"0.60649306\",\n \"0.60642517\",\n \"0.6062837\",\n \"0.6053333\",\n \"0.6053167\",\n \"0.60499763\",\n \"0.6046977\",\n \"0.6032638\",\n \"0.603207\",\n \"0.6031305\",\n \"0.6027027\",\n \"0.6021216\",\n \"0.6018664\",\n \"0.6018587\",\n \"0.6018218\",\n \"0.6016131\",\n \"0.60157055\",\n \"0.6012339\",\n \"0.6012002\",\n \"0.60109043\",\n \"0.6010362\",\n \"0.600816\",\n \"0.6008014\",\n \"0.6007431\",\n \"0.6004099\",\n \"0.6003529\",\n \"0.60034573\",\n \"0.5998924\",\n \"0.5996189\",\n \"0.59918016\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61071116"},"document_rank":{"kind":"string","value":"59"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":128,"numItemsPerPage":100,"numTotalItems":95772,"offset":12800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjAwNjY5MSwianRpIjoiZDg4Y2I4NzYtMGM3ZS00MjIzLTlmYTctMDk4ODYzYTYzMjYzIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwMTAyOTEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.lOB0K4fx2zbgRajT0p0UvZmXd6sRJNPhQIb0kcu2ZAmyv89KYb0yE5zMlzFAqM58g22VOcBghA3SEBqc6DHGAw","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 |
|---|---|---|---|---|---|---|
It's a method to move the object. | def move_me(self):
#self.start_pos = self.rect.center
if self.goal_pos is not None:
print(f'goal_pos: {self.goal_pos}, start_pos: {self.start_pos}')
dx = self.goal_pos[0] - self.start_pos[0]
dy = self.goal_pos[1] - self.start_pos[1]
distance = math.sqrt(dx*dx + dy*dy)
self.shift += self.s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self):\n pass",
"def move(self):\n raise NotImplementedError",
"def move(self, move):\n raise NotImplementedError()",
"def move(): #py:move\n RUR._move_()",
"def move(self, direction):\n # replace with your code\n pass",
"def move(self, direction):\n ... | [
"0.858327",
"0.8339233",
"0.7708627",
"0.7516622",
"0.7507448",
"0.7507448",
"0.74020606",
"0.7386842",
"0.7380838",
"0.7377471",
"0.7373789",
"0.72534597",
"0.72252834",
"0.7198612",
"0.7166816",
"0.71584934",
"0.71465313",
"0.71347594",
"0.71096295",
"0.7097371",
"0.7082709... | 0.0 | -1 |
It's a method to move the object. | def move_me_on_spawn(self):
if self.points_to_go:
self.start_pos = self.points_to_go[0]
for point in self.points_to_go[1:]:
for i in range(len(self.points_to_go[1:])):
self.goal_pos = self.points_to_go[i]
self.move_me()
#self.start_pos =
#print(self.goal_pos)
#if se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self):\n pass",
"def move(self):\n raise NotImplementedError",
"def move(self, move):\n raise NotImplementedError()",
"def move(): #py:move\n RUR._move_()",
"def move(self, direction):\n # replace with your code\n pass",
"def move(self, direction):\n ... | [
"0.85842174",
"0.8340159",
"0.7709202",
"0.7517611",
"0.7507434",
"0.7507434",
"0.7402334",
"0.7387477",
"0.7381314",
"0.73774827",
"0.7374565",
"0.7253425",
"0.72251827",
"0.7198465",
"0.71662813",
"0.71597916",
"0.7146346",
"0.7134991",
"0.71090806",
"0.7097772",
"0.7082437... | 0.0 | -1 |
It's a method to draw the object on the screen. | def draw_me(self):
self.image.fill((100, 200, 100))
if self.active: pg.draw.rect(self.image, (100, 100, 200), self.frame, 3) #if active => draw frame around selected entity width 3
self.display_surface.blit(self.image, self.rect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw(self, screen):",
"def __draw(self, screen):\n\n pygame.draw.rect(screen, (200, 255, 200), (self.x, self.y, self.width, self.height))",
"def draw(self, screen):\n screen.blit(self.surface, self.rect)",
"def draw(self):\n self.screen.fill(BACKGROUND_COLOR)\n self.cannon.dra... | [
"0.8639596",
"0.8463629",
"0.84310234",
"0.8336981",
"0.820263",
"0.8195842",
"0.8181905",
"0.8128786",
"0.8048422",
"0.8048422",
"0.8048422",
"0.8048422",
"0.79957294",
"0.7939785",
"0.7935518",
"0.79080766",
"0.78791046",
"0.7865038",
"0.7848005",
"0.78259814",
"0.78093797"... | 0.78702897 | 17 |
It's a method to draw the object on the screen. | def draw_a50(self):
pg.draw.rect(self.image, (100, 200, 100), self.rect)
#self.display_surface.blit(self.image, self.rect)
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw(self, screen):",
"def __draw(self, screen):\n\n pygame.draw.rect(screen, (200, 255, 200), (self.x, self.y, self.width, self.height))",
"def draw(self, screen):\n screen.blit(self.surface, self.rect)",
"def draw(self):\n self.screen.fill(BACKGROUND_COLOR)\n self.cannon.dra... | [
"0.8639686",
"0.84641725",
"0.84318274",
"0.83380365",
"0.82032436",
"0.81964034",
"0.8182908",
"0.8129538",
"0.8049066",
"0.8049066",
"0.8049066",
"0.8049066",
"0.799628",
"0.7940632",
"0.79363257",
"0.79091257",
"0.78803986",
"0.78708935",
"0.7866067",
"0.78481585",
"0.7827... | 0.0 | -1 |
It's a method to select the object with a mouse LEFT click. | def deselect_me(self):
self.active = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mouse_left_down(self):\n pass",
"def LeftClick(self):\n self._PressLeftButton()\n self._ReleaseAllButtons()",
"def on_left_mouse_click(self, event: Event) -> None:\n\t\tself.mouse_state.set_click(event.x, event.y)",
"def leftButtonDown(self):\n\t\tautopy.mouse.toggle(True,autopy.mouse.LEFT_B... | [
"0.7849615",
"0.7681661",
"0.7543148",
"0.7468128",
"0.7089086",
"0.7034825",
"0.69766486",
"0.6889817",
"0.67133605",
"0.66693765",
"0.6659412",
"0.6632614",
"0.6627473",
"0.6620587",
"0.66194576",
"0.66029096",
"0.6590843",
"0.65843195",
"0.6572333",
"0.6533226",
"0.6508757... | 0.0 | -1 |
Gets two positive integer numbers m and n (m > n). Returns True if they are coprime, otherwise, returns False. | def coprime(m,n):
# The function uses the Euclid's algorithm for finding the greatest common divisor. The algorithm is recursive.
# If the GCD is 1, when the numbers are coprime. If it is greater than 1, when the numbers aren't coprime.
if n == 0 and m > 1:
return False
elif n == 0 and m ==... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coprime(a: int, b: int):\n\n return euclid(a, b) == 1",
"def coprime(a, b):\n return gcd(a, b) == 1",
"def coprime(self,x,y):\r\n return x == 1 or y == 1 or not bool(self.cofactors(x,y))",
"def is_relatively_prime(n, m):\n result = True\n larger = n\n if m > n:\n larger = m\n... | [
"0.79076767",
"0.7667604",
"0.72574323",
"0.6289784",
"0.59262717",
"0.5853223",
"0.5806163",
"0.5744549",
"0.5737769",
"0.5737769",
"0.5732557",
"0.5720091",
"0.56966656",
"0.56965023",
"0.568913",
"0.5660022",
"0.5632094",
"0.5599034",
"0.5597036",
"0.55894285",
"0.5589392"... | 0.7949466 | 0 |
Gets the range of possible integer perimeters. Generates a set of all possible perimeters of rightangled triangles with integer sides. Also generates a set of perimeters of rightangled triangles with integer sides which can be formed using more than one set of values of the sides. | def perimeters(L,counter=0):
for m in range(2, int(L ** (1/2)) + 1):
for n in range(1, m):
limit = m * (m + n)
if limit > 750000:
break
if coprime(m,n) and ((m - n) % 2 > 0):
for k in range(1, 750000 // limit + 1):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yield_right_scalene_triangles(cls):\n for n in range(1, 10):\n m = n + 1\n while True:\n a, b, c = 2 * m * n, m * m - n * n, m * m + n * n\n if a <= 200 and b <= 200 and c <= 200:\n yield a, b, c\n m += 1\n ... | [
"0.593584",
"0.5841993",
"0.574564",
"0.5671036",
"0.5518445",
"0.54776615",
"0.54388785",
"0.54362965",
"0.52928966",
"0.52676713",
"0.5253598",
"0.5241637",
"0.52206737",
"0.5196224",
"0.51582533",
"0.51150614",
"0.50665206",
"0.50629294",
"0.49804005",
"0.49755204",
"0.497... | 0.0 | -1 |
Create a shift from a datetime. | def from_datetime(cls, position, datetime):
return cls(
position = position,
date = datetime.date(),
name = position.shiftForTime(datetime.time()),
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def timeshift(self, shift='random'):\n\n if shift == 'random':\n one_month = pd.Timedelta('30 days').value\n two_years = pd.Timedelta('730 days').value\n random_timedelta = - pd.Timedelta(random.uniform(one_month, two_years)).round('min')\n self.timeshift(random_t... | [
"0.6044403",
"0.5398259",
"0.5287457",
"0.51769984",
"0.5132189",
"0.50019145",
"0.49231648",
"0.4896712",
"0.48872542",
"0.48718226",
"0.47676012",
"0.4703589",
"0.46973696",
"0.46934074",
"0.4664867",
"0.46602306",
"0.46434352",
"0.46422106",
"0.46262237",
"0.46083966",
"0.... | 0.62300646 | 0 |
One or both of C{time} and C{name} are required. If both are provided, they must match (meaning C{time == name.value}). | def __init__(self, position, date, time=None, name=None):
if time is None:
if name is None:
raise ValueError("Both time and name may not be None.")
else:
time = name.value
if name is None:
name = position.lookupByValue(time)
el... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time_is_valid(request, day, time, name):\n\n\tif ((day != '0' and day != '6') and time.hour == 21) or time.minute != 0:\n\t\treturn False\n\n\t# George's time\n\tif name != \"George Yeh\" and day == '6' and time.hour >= 9 and time.hour < 12:\n\t\treturn False\n\n\treturn True",
"def _parse_name_time(self, na... | [
"0.6640484",
"0.64786184",
"0.63629127",
"0.5910048",
"0.57977873",
"0.5792878",
"0.57901675",
"0.5783988",
"0.57561564",
"0.5652514",
"0.56190234",
"0.56104416",
"0.5609141",
"0.54952973",
"0.5492782",
"0.54883355",
"0.54883355",
"0.5479089",
"0.5475929",
"0.54683834",
"0.54... | 0.6205939 | 3 |
Unidirectional conditional encoding model | def get_model_conditional(batch_size, max_seq_length, input_size, hidden_size, target_size,
vocab_size, pretrain, tanhOrSoftmax, dropout):
# batch_size x max_seq_length
inputs = tf.placeholder(tf.int32, [batch_size, max_seq_length])
inputs_cond = tf.placeholder(tf.int32, [batch_si... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_transform(self):\n if self.enc_types == \"label\":\n return self._label_encoding()\n elif self.enc_types == \"ohe\":\n return self._one_hot_encoder()\n elif self.enc_types == \"binary\":\n return self._binarization()\n else:\n raise Ex... | [
"0.63260204",
"0.63030267",
"0.6075851",
"0.5967848",
"0.5965372",
"0.58790743",
"0.5874796",
"0.57890356",
"0.57799464",
"0.5722842",
"0.57191926",
"0.57162666",
"0.5694521",
"0.56495357",
"0.55867964",
"0.55455726",
"0.55426574",
"0.5501296",
"0.5484576",
"0.54778284",
"0.5... | 0.0 | -1 |
LSTM over target and over tweet, concatenated | def get_model_concat(batch_size, max_seq_length, input_size, hidden_size, target_size,
vocab_size, pretrain, tanhOrSoftmax, dropout):
# batch_size x max_seq_length
inputs = tf.placeholder(tf.int32, [batch_size, max_seq_length])
inputs_cond = tf.placeholder(tf.int32, [batch_size, max_se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def LSTM_train(X_train, Y_train, X_dev, Y_dev, R_train, R_dev, hyperparams):",
"def __init__(self):\n super(biLSTM, self).__init__()\n \n # Words\n self.embedding = nn.Embedding(config.VOCAB, config.EMBED_DIM) \n self.embedding.shape = torch.Tensor(config.BATCH_SIZE, 5*config.E... | [
"0.67408913",
"0.6457854",
"0.64562833",
"0.63649803",
"0.63074315",
"0.6204652",
"0.62009096",
"0.61928713",
"0.6126765",
"0.6115002",
"0.61127365",
"0.6061078",
"0.6044729",
"0.6038946",
"0.5991248",
"0.5983274",
"0.5976194",
"0.5951641",
"0.59376055",
"0.59331805",
"0.5918... | 0.60012954 | 14 |
LSTM over tweet only | def get_model_tweetonly(batch_size, max_seq_length, input_size, hidden_size, target_size,
vocab_size, pretrain, tanhOrSoftmax, dropout):
# batch_size x max_seq_length
inputs = tf.placeholder(tf.int32, [batch_size, max_seq_length])
cont_train = True
if pretrain == "pre":
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def LSTM_train(X_train, Y_train, X_dev, Y_dev, R_train, R_dev, hyperparams):",
"def lstm_infer_vector(lstm_model, txt, stopwords,word_indices, maxlen=10, taillemax=300) :\n \n txt_prep = gensim.utils.simple_preprocess(txt, deacc=True)\n txt_wo_uw = remove_unknown_words(txt_prep, word_indices)\n txt_w... | [
"0.69259703",
"0.6396579",
"0.63238174",
"0.6247593",
"0.6204757",
"0.62018347",
"0.62017447",
"0.6161664",
"0.61093134",
"0.6070913",
"0.6062975",
"0.60444057",
"0.6001166",
"0.5980393",
"0.59802103",
"0.5965758",
"0.5951675",
"0.5950302",
"0.5941786",
"0.5909258",
"0.589360... | 0.65407586 | 1 |
Experimental, feed target during tweet processing | def get_model_conditional_target_feed(batch_size, max_seq_length, input_size, hidden_size, target_size,
vocab_size, pretrain, tanhOrSoftmax, dropout):
# batch_size x max_seq_length
inputs = tf.placeholder(tf.int32, [batch_size, max_seq_length])
inputs_cond = tf.placehol... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_tweet(self, tweet):\n pass",
"def handler(event,context):\n tweet = setup_and_get_tweet()\n send_tweet(tweet)",
"def main():\r\n \r\n from TweetProcessor import TweetProcessor\r\n \r\n consumer_key = ''\r\n consumer_secret = ''\r\n tweepy_base_filter = \"Filter:links -Filt... | [
"0.7313502",
"0.69035405",
"0.6865521",
"0.68484783",
"0.6787863",
"0.6676291",
"0.6539487",
"0.65331274",
"0.65195614",
"0.6417536",
"0.63775533",
"0.6372511",
"0.6360895",
"0.63496524",
"0.63423645",
"0.632423",
"0.631834",
"0.62835366",
"0.6275059",
"0.62618613",
"0.622733... | 0.0 | -1 |
Bidirectional conditional encoding with separate embeddings matrices for tweets and targets lookup | def get_model_bicond_sepembed(batch_size, max_seq_length, input_size, hidden_size, target_size,
vocab_size, pretrain, tanhOrSoftmax, dropout):
# batch_size x max_seq_length
inputs = tf.placeholder(tf.int32, [batch_size, max_seq_length])
inputs_cond = tf.placeholder(tf.int32, [... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode_decode_TD(self, n_step, idx_list_previous, log_probs_previous, entropies_previous, mask_previous, query1_previous, query2_previous, query3_previous, idx_ ):\r\n\r\n actor_embedding = embed_seq(input_seq=self.input_, from_=self.dimension, to_= self.input_embed, is_training=self.is_training, BN=Tru... | [
"0.62304574",
"0.61581886",
"0.60888433",
"0.6022857",
"0.6010236",
"0.59635216",
"0.59596765",
"0.59439564",
"0.5934304",
"0.592322",
"0.5922254",
"0.5914548",
"0.59115756",
"0.586454",
"0.5857956",
"0.581915",
"0.5815731",
"0.57856417",
"0.5763882",
"0.57341534",
"0.5730271... | 0.555872 | 45 |
Method for creating the different models and training them | def test_trainer(testsetting, w2vmodel, tweets, targets, labels, ids, tweets_test, targets_test, labels_test, ids_test, hidden_size, max_epochs, tanhOrSoftmax, dropout, modeltype="conditional", targetInTweet={}, testid = "test-1", pretrain = "pre_cont", acc_thresh=0.9, sep = False):
# parameters
learning_rate ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_models(self):\n scores = {}\n for name, clf in self.__clfs.items():\n print('=' * 80)\n print(name)\n scores[name] = self.__benchmark(clf)\n best = self.__get_best_score(scores)\n best_params = self.optimize(self.__clfs[best])\n simple_s... | [
"0.76776975",
"0.76045287",
"0.7354052",
"0.7263279",
"0.7256921",
"0.7252735",
"0.72468996",
"0.724567",
"0.7220866",
"0.72174674",
"0.72167915",
"0.7209326",
"0.7187799",
"0.7158652",
"0.71488",
"0.7124282",
"0.7107402",
"0.70929474",
"0.70569545",
"0.70513165",
"0.70222586... | 0.0 | -1 |
Reading input files, calling the trainer for training the model, evaluate with official script | def readInputAndEval(testSetting, outfile, hidden_size, max_epochs, tanhOrSoftmax, dropout, stopwords="most", testid="test1", modeltype="bicond", word2vecmodel="small", postprocess=True, shortenTargets=False, useAutoTrump=False, useClinton=True, acc_thresh=1.0, pretrain="pre_cont", usePhrases=False):
if word2vecm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n data = load_data()\n analyze_features(data['full_features'])\n model = train(data)\n\n with open('model.pickle', 'wb') as f:\n pickle.dump(model, f)\n evaluate(model, data)",
"def train(self, trainfile):",
"def main():\r\n # Read dataset.\r\n reader = DatasetReader\r\n tr... | [
"0.7480094",
"0.7215712",
"0.7188897",
"0.7166654",
"0.7165199",
"0.7164453",
"0.6992235",
"0.6970149",
"0.6936405",
"0.6928871",
"0.6909906",
"0.6889421",
"0.68563586",
"0.685357",
"0.6827311",
"0.68212926",
"0.6818569",
"0.68144375",
"0.68039346",
"0.67896914",
"0.6782234",... | 0.64902997 | 56 |
Get the current user. | def get_me(self):
return self._api_call('get', '/me') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_current_user(self):\n return self.current_user",
"def get_current_user(self):\n return self.get_secure_cookie(\"user\")",
"def current_user(self):\n user_dict = self.auth.get_user_by_session()\n return self.auth.store.user_model.get_by_id(user_dict['user_id'])",
"def current_user(... | [
"0.8836685",
"0.87018216",
"0.86910814",
"0.8619504",
"0.85802186",
"0.8505428",
"0.8505428",
"0.8505428",
"0.8500047",
"0.8500047",
"0.84839404",
"0.8483425",
"0.84567",
"0.838958",
"0.8296931",
"0.8281396",
"0.82328916",
"0.815139",
"0.8126627",
"0.8124535",
"0.81106335",
... | 0.0 | -1 |
Get teams owned by the account. | def get_teams(self, account_id):
endpoint = '/accounts/{}/teams'.format(account_id)
return self._api_call('get', endpoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_teams(self):\n url = 'teams'\n result = self.get(url)\n return result.get('teams', result)",
"def get_teams(self, *args, **kwargs):\n\n teams_data = api.get_teams(\n *args,\n api_key=self.__creds.api_key_v2,\n **kwargs)\n return [en.Team... | [
"0.7548286",
"0.7198719",
"0.7053132",
"0.70429367",
"0.70303184",
"0.6919348",
"0.6908395",
"0.6904372",
"0.68936974",
"0.6875712",
"0.6783006",
"0.67675626",
"0.67675245",
"0.6744305",
"0.6626937",
"0.66002136",
"0.65531397",
"0.64464307",
"0.6432558",
"0.6408208",
"0.63947... | 0.7758869 | 0 |
Get projects owned by the team. | def get_projects(self, team_id):
endpoint = '/teams/{}/projects'.format(team_id)
return self._api_call('get', endpoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_projects(self):\n return self._gitlab.owned_projects(per_page=1000)",
"def get_projects(self):\n return self.http_call(\"get\", url=f\"{self.base_url}/projects\").json()",
"def get_projects(self):\n projects = []\n page = 1\n while not len(projects) % 100:\n ... | [
"0.8055631",
"0.71431756",
"0.6982873",
"0.6950596",
"0.69087213",
"0.68157524",
"0.6773247",
"0.6765266",
"0.67424154",
"0.66995823",
"0.66808534",
"0.6675837",
"0.66692793",
"0.6655742",
"0.66494966",
"0.6611001",
"0.66000354",
"0.6599352",
"0.6567951",
"0.65166676",
"0.651... | 0.720342 | 1 |
Get a project by id. | def get_project(self, project_id):
endpoint = '/projects/{}'.format(project_id)
return self._api_call('get', endpoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_project(self, id):\n for project in self.projects:\n if project.id == int(id):\n ret_val = project\n break\n else:\n ret_val = None\n\n return ret_val",
"def get_project(project_id):\n return Project.objects.get(id=project_id)",
... | [
"0.85450214",
"0.848927",
"0.8266412",
"0.80974513",
"0.80609334",
"0.8044354",
"0.8024351",
"0.78656834",
"0.773265",
"0.7671528",
"0.7634889",
"0.74409455",
"0.7180909",
"0.7140296",
"0.7125609",
"0.709435",
"0.7068609",
"0.69485366",
"0.68705076",
"0.6820544",
"0.668665",
... | 0.83762926 | 2 |
Get an asset by id. | def get_asset(self, asset_id):
endpoint = '/assets/{}'.format(asset_id)
return self._api_call('get', endpoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_asset(self, asset_id):\n text, code = ApiClient(self._config, 'assets/' + asset_id).get()\n return Asset.deserialize(text)",
"def get_asset(self, asset_id, asset_type):\n return self.asset(asset_id, asset_type=asset_type)",
"def asset(self, asset_id):\n headers, items = self... | [
"0.8605014",
"0.8052259",
"0.7977259",
"0.78436553",
"0.7251006",
"0.7176857",
"0.69656426",
"0.6938977",
"0.6917505",
"0.66144365",
"0.65986526",
"0.6570589",
"0.6543234",
"0.6528059",
"0.64717233",
"0.6465809",
"0.6415963",
"0.6392111",
"0.638581",
"0.6384934",
"0.6381671",... | 0.8775442 | 0 |
Get an asset's children. | def get_asset_children(self, asset_id):
endpoint = '/assets/{}/children'.format(asset_id)
return self._api_call('get', endpoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def children(self) -> \"AssetList\":\n return self._cognite_client.assets.list(parent_ids=[self.id], limit=None)",
"def get_children(self):\r\n\r\n if not self.has_children:\r\n return []\r\n\r\n if getattr(self, '_child_instances', None) is None:\r\n self._child_instan... | [
"0.80006397",
"0.691222",
"0.6860828",
"0.68368614",
"0.68368614",
"0.68368614",
"0.68265384",
"0.6793676",
"0.6740953",
"0.6736009",
"0.6700646",
"0.6693795",
"0.6691179",
"0.6656253",
"0.66030985",
"0.6577579",
"0.655715",
"0.655715",
"0.6483371",
"0.64426744",
"0.64426744"... | 0.8664441 | 0 |
Upload an asset. The method will exit once the file is uploaded. | def upload(self, asset, file):
uploader = FrameioUploader(asset, file)
uploader.upload() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upload_asset(ctx, asset, release):\n\n try:\n\n gh = ctx.obj.github\n\n log.echo('Uploading {} to release {}...'\n .format(os.path.basename(asset), release), break_line=False)\n asset_url = gh.upload_asset(asset=asset, release=release)\n log.checkmark()\n l... | [
"0.7121886",
"0.6898182",
"0.67980725",
"0.6593342",
"0.6541552",
"0.6339619",
"0.6255667",
"0.6252402",
"0.62079424",
"0.6194437",
"0.6188706",
"0.61695176",
"0.6163366",
"0.61349344",
"0.61055654",
"0.6055838",
"0.6012874",
"0.5993593",
"0.5967045",
"0.59558564",
"0.5932348... | 0.7988663 | 0 |
Get an asset's comments. | def get_comments(self, asset_id):
endpoint = '/assets/{}/comments'.format(asset_id)
return self._api_call('get', endpoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_comments(self):\n\t\treturn self._client.get_comments(self)",
"def comments(self):\n comments_url = self.data['comments_url']\n return json.load(urllib2.urlopen(comments_url))",
"def comments(self):\n return self.container['comments']",
"def get(self, id):\n return get_com... | [
"0.7266864",
"0.6898062",
"0.67627263",
"0.66801363",
"0.66657114",
"0.66657114",
"0.6650718",
"0.6621939",
"0.65967107",
"0.65728563",
"0.6548351",
"0.6507441",
"0.6507441",
"0.6507441",
"0.63552064",
"0.63516146",
"0.6345878",
"0.6339328",
"0.6319697",
"0.63146293",
"0.6279... | 0.87023836 | 0 |
Get the review links of a project | def get_review_links(self, project_id):
endpoint = '/projects/{}/review_links'.format(project_id)
return self._api_call('get', endpoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grab_project_links(soup):\n project_urls = []\n valid_project_url = \"/?archive/?gsoc/\\d+[0-9]/orgs/[a-zA-Z]+/[a-zA-Z]+/[a-zA-Z]+.html\"\n try:\n # Grab links to all the projects\n all_link = soup.find_all(\"a\")\n for link in all_link:\n if re.match(valid_project_url,... | [
"0.6268083",
"0.62558377",
"0.6122463",
"0.6031433",
"0.60285616",
"0.59528255",
"0.5925954",
"0.58337975",
"0.57853",
"0.57034177",
"0.5673401",
"0.56721526",
"0.563363",
"0.56289285",
"0.56215906",
"0.5591778",
"0.5589715",
"0.5549578",
"0.5547254",
"0.55213386",
"0.5512712... | 0.7728808 | 0 |
Create a review link. | def create_review_link(self, project_id, **kwargs):
endpoint = '/projects/{}/review_links'.format(project_id)
return self._api_call('post', endpoint, payload=kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def review_link(self, review_link):\n\n self._review_link = review_link",
"def createLink(context, title, link, exclude_from_nav=False):\n oid = idnormalizer.normalize(title, 'es')\n if not hasattr(context, oid):\n context.invokeFactory('Link', id=oid, title=title, remoteUrl=link)\n li... | [
"0.67446196",
"0.59985214",
"0.58935666",
"0.5819669",
"0.57771635",
"0.57548815",
"0.56993616",
"0.5654442",
"0.5638429",
"0.5629432",
"0.56153315",
"0.56034595",
"0.5595337",
"0.5588098",
"0.558482",
"0.55711055",
"0.5541868",
"0.55295026",
"0.5524608",
"0.5522368",
"0.5497... | 0.77476805 | 0 |
Get a single review link | def get_review_link(self, link_id, **kwargs):
endpoint = '/review_links/{}'.format(link_id)
return self._api_call('get', endpoint, payload=kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_review_page(review_link):\n\n session = r.Session()\n response = session.get(BASE_URL + '/music/albumreviews/' + review_link,\n headers=HEADERS)\n return response",
"def get_review(review_id):\n return get(cls, review_id)",
"def get_content_object_url(self):\n ... | [
"0.6831752",
"0.64643896",
"0.6345438",
"0.6279402",
"0.6228978",
"0.61699647",
"0.61587733",
"0.612717",
"0.6065012",
"0.60605973",
"0.603731",
"0.5991732",
"0.5958937",
"0.5925658",
"0.58885676",
"0.576672",
"0.57320416",
"0.57320416",
"0.57136726",
"0.5682893",
"0.5650391"... | 0.6617292 | 1 |
Add or update assets for a review link. | def update_review_link_assets(self, link_id, **kwargs):
endpoint = '/review_links/{}/assets'.format(link_id)
return self._api_call('post', endpoint, payload=kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def review_link(self, review_link):\n\n self._review_link = review_link",
"def linkAssets(des, Xrc):\n with open(des, 'r') as f:\n body = f.read()\n f.close()\n with open(des, 'w') as f:\n body = body.replace(\"custom.css\", \"\\\\\" + Xrc[\"gh_repo_name\"] + \"/Assets\" + \"/cs... | [
"0.59623325",
"0.5327148",
"0.51797146",
"0.5134346",
"0.49140236",
"0.48908433",
"0.4881912",
"0.48579592",
"0.4842742",
"0.48399702",
"0.4804743",
"0.47892767",
"0.47684696",
"0.47508633",
"0.4741797",
"0.47353303",
"0.47250083",
"0.46850595",
"0.46558216",
"0.4654844",
"0.... | 0.74828833 | 0 |
Get items from a single review link. | def get_review_link_items(self, link_id):
endpoint = '/review_links/{}/items'.format(link_id)
return self._api_call('get', endpoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_review_page(review_link):\n\n session = r.Session()\n response = session.get(BASE_URL + '/music/albumreviews/' + review_link,\n headers=HEADERS)\n return response",
"def get_reviews(item_id, shop_id, review_num=10) -> list:\n get_url = f\"{_shopee_base_url}/api/v2/it... | [
"0.6445965",
"0.6111887",
"0.59627175",
"0.59522223",
"0.5802556",
"0.5668858",
"0.56402814",
"0.56334907",
"0.5598594",
"0.5478629",
"0.5376781",
"0.5351566",
"0.5350795",
"0.534827",
"0.53360826",
"0.5320217",
"0.52967834",
"0.5288006",
"0.52783906",
"0.52698594",
"0.525339... | 0.70730585 | 0 |
Returns mean for all elements past current (including current) for every point | def expanding_mean(arr):
total_len = arr.shape[0]
return ((arr / total_len).cumsum() / np.arange(1, total_len + 1)) * total_len | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean(points):\r\n\t\treturn sum(points)/len(points)",
"def point_avg(points):\n if len(points)==1:\n new_center= np.mean(points)\n else:\n new_center= [np.mean([x[y] for x in points]) for y in range(len(points[0]))]\n return new_center",
"def current_mean(self):\r\n values = s... | [
"0.7258874",
"0.7101988",
"0.70291924",
"0.6934186",
"0.6857672",
"0.6841803",
"0.67217815",
"0.6639915",
"0.66098267",
"0.65969443",
"0.65851164",
"0.6567137",
"0.65645444",
"0.6561704",
"0.6561704",
"0.6561704",
"0.6561704",
"0.6561704",
"0.6561704",
"0.6542912",
"0.6536134... | 0.0 | -1 |
Given an imaging server fqdn, get its ID; raises NotFound if not found. | def get_id(self, fqdn):
res = self.db.execute(sqlalchemy.select([ model.imaging_servers.c.id ],
whereclause=(model.imaging_servers.c.fqdn==fqdn)))
return self.singleton(res) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def id(self):\n if self.cloudserver:\n return self.cloudserver.id\n else:\n return None",
"def get_dnid_by_dnname(self, dnname):\r\n for dn in self.dns:\r\n if dn.name == dnname:\r\n return dn.id\r\n return None",
"def fqdn_identifier(... | [
"0.60768455",
"0.5970655",
"0.5924284",
"0.5919874",
"0.58456326",
"0.5822033",
"0.5815973",
"0.580934",
"0.5719458",
"0.56800956",
"0.56767",
"0.566704",
"0.5608655",
"0.55602825",
"0.5556568",
"0.55522054",
"0.5534244",
"0.55294096",
"0.5518612",
"0.5512121",
"0.5504768",
... | 0.7955763 | 0 |
Return a list of the fqdn's of all imaging servers | def list(self):
res = self.db.execute(select([model.imaging_servers.c.fqdn]))
return self.column(res) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ns_list(self):\n return sorted(self.get_ns_name(ns) for ns in self.profile.authoritative_servers)",
"def ip_addresses(self):\n try:\n return socket.gethostbyaddr(self.fqdn)[-1]\n except socket.error as _:\n return ['127.0.0.1']",
"def list_distributed_cameras(ns_h... | [
"0.6587762",
"0.65380913",
"0.6459177",
"0.6459177",
"0.6430747",
"0.6372296",
"0.6362174",
"0.633885",
"0.6327382",
"0.6309077",
"0.6303938",
"0.62505966",
"0.62255406",
"0.6212317",
"0.6186019",
"0.6185925",
"0.6149783",
"0.6135975",
"0.61257327",
"0.60628873",
"0.60275596"... | 0.77899426 | 0 |
Place various obstacles. E.g. put in rectangles which block the line of site of the towers. | def place_obstacles():
#Randomly generate different sized rectangles
#Soem may overlap, which gives more variety in shape of obstacles
xvals = np.random.randint(0,self.map_dimensions[1],size=self.N_obstacles)
yvals = np.random.randint(0,self.map_dimensions[0],size=self.N_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_obstacles(self):\n for obstacle in self.obstacles:\n obstacle.draw(self.window, Colors.BLACK.value)",
"def draw_obstacles():\n for obstacle in obstacles:\n plt.gca().add_patch(obstacle)",
"def spawn_obstacles(self):\n self.obstacle_sprites.empty()\n number_of_... | [
"0.7180668",
"0.6907903",
"0.66251636",
"0.65257436",
"0.6507786",
"0.6495422",
"0.64418054",
"0.63769335",
"0.6216832",
"0.6200093",
"0.6169618",
"0.6096015",
"0.6086622",
"0.60711867",
"0.601048",
"0.60011566",
"0.59804374",
"0.59804374",
"0.59792244",
"0.5943572",
"0.59333... | 0.79376906 | 0 |
Place the target locations | def place_targets():
coords = []
while len(coords)<self.N_targets:
x = np.random.randint(self.BORDER_MARGIN,self.map_dimensions[1]+1-self.BORDER_MARGIN,size=1)[0]
y = np.random.randint(self.BORDER_MARGIN,self.map_dimensions[0]+1-self.BORDER_MARGIN,si... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_targets(self):\n for ga_main, ga_targ in zip(self.ga.variables, self.ga_.variables):\n ga_targ.assign(ga_main)\n if self.use_lyapunov:\n for lc_main, lc_targ in zip(self.lc.variables, self.lc_.variables):\n lc_targ.assign(lc_main)\n else:\n ... | [
"0.6060867",
"0.5983119",
"0.59704787",
"0.5942067",
"0.5901007",
"0.588003",
"0.58684736",
"0.58369666",
"0.58147174",
"0.58143884",
"0.5814113",
"0.5796882",
"0.5793904",
"0.57164675",
"0.5716242",
"0.57001746",
"0.56815624",
"0.56712925",
"0.5663553",
"0.5660132",
"0.56310... | 0.71361285 | 0 |
Place the potential tower locations. These are the locations where towers can potentially be placed. Not every location is necesarily used (only when N_tower_sites = N_towers). THe optimization problem is to determine which of these possible locations to use. | def place_allowed_tower_sites():
self.coordinates__tower_sites = []
for tk in xrange(self.N_tower_kinds):
#Each kind of tower will have the correct number of sites placed
coords = []
while len(coords)<self.N_tower_sites[tk]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve_environment(self):\n \n #The first problem formulation\n #K kinds of towers\n #See more details about problem formulation in the writeup \n \n #Get a full matrix of the concatenated coverage matrices for \n #each tower type. THis new matrix has... | [
"0.58460766",
"0.57772356",
"0.5284448",
"0.52179706",
"0.5182957",
"0.5147743",
"0.5096863",
"0.50870997",
"0.50867623",
"0.5045977",
"0.502303",
"0.49666467",
"0.49650604",
"0.49317968",
"0.49126053",
"0.49000195",
"0.48980615",
"0.48955286",
"0.4892086",
"0.48821265",
"0.4... | 0.79918706 | 0 |
return True if r1 r2 line of sight is obstrucetd; oherwise False | def check_obstructed(r1,r2):
if r1==r2:
return False
#Densely sample line connecting r1 and r2.
#If any of those sampled points is inside the rectangle, then the
#line of sight intersects the rectangle and the tower's... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_ok_two_lines(line1, line2):\n card1 = line1[0]\n card2 = line1[1]\n card3 = line1[2]\n card4 = line2[0]\n card5 = line2[1]\n card6 = line2[2]\n idents1 = [card.ident for card in line1]\n idents2 = [card.ident for card in line2]\n intersection = list(set(idents1) & set(idents2))\n ... | [
"0.6848249",
"0.64294106",
"0.63830334",
"0.6372023",
"0.6302667",
"0.6286635",
"0.627175",
"0.62661767",
"0.62325734",
"0.6230347",
"0.61978024",
"0.6182168",
"0.6139048",
"0.6096409",
"0.60867286",
"0.6068303",
"0.60645324",
"0.60228837",
"0.60018134",
"0.5998949",
"0.59936... | 0.7739377 | 0 |
Visualize the map environment and solved tower locations. env_state = 'solved', 'initial' | def visualize_environment(self,env_state):
fig=plt.figure(figsize=self.figsize)
ax=plt.subplot(111)
#Plot the targets
plt.plot([i[0] for i in self.coordinates__targets],\
[i[1] for i in self.coordinates__targets],\
marker='x',markersize=15,linestyle='Non... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize_world(self, brain):\n state_str = ' || '.join([str(self.sensors),\n str(self.actions),\n str(self.reward),\n str(self.size),\n str(self.color),\n ... | [
"0.6409097",
"0.6119604",
"0.5912742",
"0.586634",
"0.58319414",
"0.57472837",
"0.5705525",
"0.5673055",
"0.5668513",
"0.5658401",
"0.56487894",
"0.56268203",
"0.5603009",
"0.55793464",
"0.55743",
"0.55685604",
"0.5551185",
"0.5547571",
"0.54791296",
"0.547258",
"0.54570925",... | 0.8492099 | 0 |
The placement problem is a combinatorial optimization problem, so in general will be NP hard. But we can use convex relaxation to reformulate it as a convex optimization problem. Then we can use the Iterated Weighted L1 Heuristic to encourage sparse solutions and recover a viable solution to the placement problem. | def solve_environment(self):
#The first problem formulation
#K kinds of towers
#See more details about problem formulation in the writeup
#Get a full matrix of the concatenated coverage matrices for
#each tower type. THis new matrix has dimensions:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(num_wizards, num_constraints, wizards, constraints): \n global wiz_const\n wiz_const = mapConstraints(wizards, constraints)\n partial_soltns = []\n\n # counter for priority queue since it doesn't allow \n # identical priorities\n k = 0\n\n # list of wizards sorted by lowest to highes... | [
"0.6252057",
"0.6099802",
"0.6056199",
"0.5994748",
"0.59845185",
"0.59784395",
"0.5769586",
"0.574486",
"0.5744253",
"0.57309437",
"0.5724893",
"0.5709498",
"0.5692334",
"0.56834733",
"0.56792754",
"0.5677139",
"0.5663982",
"0.565795",
"0.56319666",
"0.56297445",
"0.56293243... | 0.58186674 | 6 |
Run the whole scenario. Initialize map, solve placement, visualize everything. | def run_scenario(self):
self.initialize_random_map()
self.visualize_environment('initial')
self.get_tower_target_coverages()
self.solve_environment()
self.visualize_environment('solved') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n # Return needed Data Frames to analyze\n data_frame, seasons, col, labels, stats, kaggle = load_frames()\n\n # Create the maps now\n create_shot_maps(data_frame,seasons)\n create_scenario_map()\n \n # Create the Plots\n plot_season_graphs(stats)\n plot_pie_charts(kaggle)\n ... | [
"0.7093898",
"0.6963387",
"0.67339575",
"0.6569679",
"0.61990684",
"0.61964035",
"0.61749303",
"0.6154679",
"0.61539835",
"0.6101129",
"0.60104483",
"0.5999573",
"0.5993726",
"0.5986674",
"0.59698826",
"0.5956886",
"0.5940285",
"0.5927748",
"0.5921149",
"0.5909592",
"0.590016... | 0.8375138 | 0 |
Converting from python list to c array | def c_array(ctype, values):
arr = (ctype*len(values))()
arr[:] = values
return arr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_array(self, c):\n return (c * ctypes.py_object)()",
"def _cast_strlist_to_C(py_strlist):\n c_strarr = (str_t * len(py_strlist))()\n c_strarr[:] = py_strlist\n return c_strarr",
"def decode(lst, typecode ):\n a = array.array( typecode )\n for n,c in lst: \n a.extend( array... | [
"0.77845",
"0.7144514",
"0.6911046",
"0.63947684",
"0.63339645",
"0.6281343",
"0.62734985",
"0.6220384",
"0.620282",
"0.61711013",
"0.61647403",
"0.61425847",
"0.61346316",
"0.6129619",
"0.6120571",
"0.61136305",
"0.61050606",
"0.60756564",
"0.60618967",
"0.6021413",
"0.60184... | 0.7057583 | 2 |
getting yolo results return dict | def get_detect_result(self):
resultdict = {'class_index' : self.class_index,
'obj_name' : self.obj_name,
'score' : self.score,
'bounding_box' : {
'x_min' : self.x_min,
'y_min' : self.y_min,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yolo_show(image_path_list, batch_list):\n font = cv2.FONT_HERSHEY_SIMPLEX\n for img_path, batch in zip(image_path_list, batch_list):\n result_list = batch.tolist()\n img = cv2.imread(img_path)\n for result in result_list:\n cls = int(result[0])\n bbox = result[1... | [
"0.6200471",
"0.61258125",
"0.60596544",
"0.60579133",
"0.6020937",
"0.58768976",
"0.5827106",
"0.58051485",
"0.57187974",
"0.5619059",
"0.5576724",
"0.54857856",
"0.5460958",
"0.54230195",
"0.5414441",
"0.5305155",
"0.52727157",
"0.52549005",
"0.5240237",
"0.5231136",
"0.520... | 0.5629328 | 9 |
converting from cv2 image class to yolo image class | def _convert_to_yolo_img(self, img):
img = img / 255.0
h, w, c = img.shape
img = img.transpose(2, 0, 1)
outimg = make_image(w, h, c)
img = img.reshape((w*h*c))
data = c_array(c_float, img)
outimg.data = data
rgbgr_image(outimg)
return outimg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yolo_detection(raw_image):\n class_ids = []\n confidences = []\n boxes = []\n height , width ,c= raw_image.shape\n blob = cv2.dnn.blobFromImage(raw_image, 0.00392, (416,416), (0,0,0), True, crop=False)\n net.setInput(blob)\n outs = net.forward(output_layers)\n\n for out in outs:\n ... | [
"0.69979674",
"0.6875691",
"0.6409599",
"0.6264038",
"0.6263965",
"0.62305474",
"0.6210611",
"0.61554116",
"0.6152523",
"0.61343765",
"0.6091251",
"0.60643476",
"0.6000393",
"0.59585893",
"0.59381723",
"0.59326524",
"0.5932447",
"0.591459",
"0.58689374",
"0.5849591",
"0.58300... | 0.73024845 | 0 |
Getting color based on yolo src | def _get_color(self, c, x, max_num):
ratio = 5*(float(x)/max_num)
i = int(math.floor(ratio))
j = int(math.ceil(ratio))
ratio -= i
r = (1 - ratio) * self._colors[i][c] + ratio*self._colors[j][c]
return int(255*r) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def colorsrc(self):\n return self['colorsrc']",
"def get_color(im_obj):\n #im = Image.open(path, 'r')\n x, y = im_obj.size\n\n r, g, b = 0, 0, 0\n for i in xrange(x):\n for j in xrange(y):\n color_px = im_obj.getpixel((i, j))\n #print color_px\n r += col... | [
"0.6382341",
"0.63190573",
"0.628886",
"0.6217046",
"0.60708547",
"0.605908",
"0.6039326",
"0.595254",
"0.59011966",
"0.58598113",
"0.58473456",
"0.5846212",
"0.5841965",
"0.5841965",
"0.5841965",
"0.5841965",
"0.5837148",
"0.582855",
"0.5776561",
"0.5775572",
"0.57513714",
... | 0.52407795 | 97 |
drawing result of yolo | def draw_detections(self, img, yolo_results):
_, height, _ = img.shape
for yolo_result in yolo_results:
class_index = yolo_result.class_index
obj_name = yolo_result.obj_name
x = yolo_result.x_min
y = yolo_result.y_min
w = yolo_result.width
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw():",
"def yolo_show(image_path_list, batch_list):\n font = cv2.FONT_HERSHEY_SIMPLEX\n for img_path, batch in zip(image_path_list, batch_list):\n result_list = batch.tolist()\n img = cv2.imread(img_path)\n for result in result_list:\n cls = int(result[0])\n ... | [
"0.6624572",
"0.6562952",
"0.6472424",
"0.6423379",
"0.6327614",
"0.62627614",
"0.60913956",
"0.6042178",
"0.5875701",
"0.5875701",
"0.5875701",
"0.5875701",
"0.5867414",
"0.58438444",
"0.584261",
"0.5831161",
"0.58155954",
"0.5793131",
"0.5755186",
"0.56922597",
"0.5644086",... | 0.6384654 | 4 |
Predicting from cv2 format | def predict_from_cv2(yolo, inputfilepath):
print("call func of predict_from_cv2")
img = cv2.imread(inputfilepath)
yolo_results = yolo.predict(img)
for yolo_result in yolo_results:
print(yolo_result.get_detect_result()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, img_path):\n\n img = cv2.imread(img_path)\n img0 = img.copy()\n \n #This happens inside datasets\n # Convert\n img = letterbox(img, new_shape=self.img_size)[0]\n\n # Convert\n img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x... | [
"0.769187",
"0.7126001",
"0.7057096",
"0.7030363",
"0.70179856",
"0.7012954",
"0.6988399",
"0.696144",
"0.696144",
"0.6959898",
"0.69489837",
"0.6909902",
"0.6900875",
"0.68756694",
"0.6821238",
"0.6792172",
"0.6742851",
"0.67373735",
"0.6706675",
"0.668598",
"0.6666994",
"... | 0.72321135 | 1 |
Predicting from PIL format | def predict_from_pil(yolo, inputfilepath):
print("call func of predict_from_pil")
img = np.array(Image.open(inputfilepath))
yolo_results = yolo.predict(img)
for yolo_result in yolo_results:
print(yolo_result.get_detect_result()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_image(pic_style):\n classes = [\"BAROQUE\", \"EARLY-RENAISSANCE\", \"HIGH-RENAISSANCE\", \"IMPRESSIONISM\", \"MANNERISM\",\n \"MEDIEVAL\", \"MINIMALISM\", \"NEOCLASSICISM\", \"REALISM\", \"ROCOCO\",\n \"ROMANTICISM\", \"SURREALISM\"\n ]\n\n if pic_style.... | [
"0.6664149",
"0.6654456",
"0.65723336",
"0.6510777",
"0.6439882",
"0.6420322",
"0.6417145",
"0.6387115",
"0.6382623",
"0.63690084",
"0.6353849",
"0.6336394",
"0.63333225",
"0.63284427",
"0.63270974",
"0.6322199",
"0.63044155",
"0.6290391",
"0.62887764",
"0.6276978",
"0.624016... | 0.6737026 | 0 |
Fetch a single user's data if a user_id is specified. Otherwise fetch the list of all users. Returned info contains user_id, name, group name,email, admin status, and date_created. | def get(self, user_id):
if user_id:
return get_from_user_id(user_id)
else:
# No user_id given; this is a GET all users request.
if not current_user.is_admin:
error(403, "Logged in user not admin ")
user_db_data = user_db_util.fetchall(g.da... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def fetch_user(self, id: str):\n user = await self.http.get_user(id)\n return User(state=self.http, data=user)",
"def get(self, id):\n\t\ttry:\n\t\t\tflask_app.logger.debug('We are getting the user: %d', id)\n\t\t\treturn user_service.get(id)\n\t\texcept AssertionError as e:\n\t\t\tuser_space... | [
"0.72157097",
"0.7131999",
"0.70872533",
"0.7083722",
"0.7074586",
"0.7070638",
"0.7040221",
"0.70230114",
"0.6946631",
"0.69372654",
"0.6927964",
"0.6918322",
"0.69075227",
"0.68962216",
"0.68914783",
"0.688945",
"0.6877585",
"0.6864886",
"0.6854097",
"0.68460727",
"0.681894... | 0.7235378 | 0 |
Create a new user with provided email, password, and admin flag. If required fields are missing in the request, return 400 Password must be 8 or more characters long. Otherwise return 422 Email must not already be in use by an existing user. Otherwise return 422 If success, return 201 with the new user's email, admin f... | def post(self):
data = request.get_json()
if data is None:
error(400, "No json data in request body")
check_data_fields(data, ["email", "name", "group_name", "password", "admin"])
if len(data["password"]) < 8:
error(422, "New password is less than 8 characters... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_user():\n record = request.get_json()\n if record is None:\n return {\"Error\": \"No data Supplied.\"}, 400\n\n schema = user_schema.load(record)\n\n if UserModel.objects(email=schema['email']):\n return {\"Error\": \"User Data already exists.\"}, 400\n user = UserModel(**s... | [
"0.7782959",
"0.76835763",
"0.7680565",
"0.7676472",
"0.76109964",
"0.7539318",
"0.753589",
"0.75105494",
"0.75042003",
"0.74783903",
"0.7470725",
"0.7454548",
"0.7424451",
"0.7331659",
"0.73239493",
"0.7322408",
"0.73050135",
"0.72956514",
"0.7292638",
"0.7289475",
"0.728914... | 0.7710605 | 1 |
Creates a new Match object based on arbitrary arguments which constitute a match pattern. Each argument matches an element of the original event. Arguments are matched based | def __init__(self, *args):
self.args = args
self.matchers = []
for a in args:
if a is _:
a = lambda k: True
elif isinstance(a, basestring):
a = a.__eq__
elif isinstance(a, (list, tuple, set)):
a = (lambda ary: (l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_re_match(cls, match):\n kwargs = match.groupdict()\n player_location = kwargs['player_location'].split()\n kwargs['player_location'] = (int(player_location[0]),\n int(player_location[1]),\n int(player_location[2])... | [
"0.63041854",
"0.62884766",
"0.60881954",
"0.5861523",
"0.58473384",
"0.555869",
"0.55210406",
"0.5483552",
"0.54075843",
"0.5347497",
"0.52940315",
"0.5262951",
"0.5244793",
"0.5229378",
"0.5206262",
"0.51890385",
"0.51735175",
"0.51612294",
"0.5146798",
"0.5131269",
"0.5126... | 0.58726645 | 3 |
Returns true if this object matches an arbitrary string when split on ascii spaces. | def match(self, string):
ary = string.split(' ', len(self.matchers))
if all(m(a) for m, a in zip(self.matchers, ary)):
return ary | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_string(self, s):\n\n data = s.split(' ')\n\n origin = ' '.join(data[0:-1])\n if not origin:\n return False\n \n origin_hashed = self.hash_with_salt(origin)\n\n return origin_hashed == s",
"def isspace(self) -> bool:\n pass",
"def has_whitespa... | [
"0.6801843",
"0.67221856",
"0.66555274",
"0.6536783",
"0.63486564",
"0.63276196",
"0.63195336",
"0.629289",
"0.62802047",
"0.62746346",
"0.6175623",
"0.6119683",
"0.61172634",
"0.6080486",
"0.6064205",
"0.60596126",
"0.6014171",
"0.6013115",
"0.5970804",
"0.59225404",
"0.5912... | 0.60266405 | 16 |
Given an iterator which returns (key, value) pairs, returns a new iterator of (k, value) pairs such that every list or tuplevalued key in the original sequence yields an individual pair. | def flatten(items):
for k, v in items:
if isinstance(k, (list, tuple)):
for key in k:
yield key, v
else:
yield k, v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iter_pairs(iterable):\n if isinstance(iterable, Mapping):\n iterable = iterable.items()\n return iter(iterable)",
"def pairs(iterable):\n previous = None\n for item in iterable:\n current = item\n if previous is not None:\n yield previous, current\n previous... | [
"0.691934",
"0.64335775",
"0.6234379",
"0.62247425",
"0.6090052",
"0.6072828",
"0.6056752",
"0.6033201",
"0.60265905",
"0.59873533",
"0.59600586",
"0.5856685",
"0.58540154",
"0.5830519",
"0.58234537",
"0.57890534",
"0.5769367",
"0.57635",
"0.57286495",
"0.5683447",
"0.5672941... | 0.513164 | 94 |
Initializes the event handler | def __init__(self):
self.events = {}
self.eventmatchers = {}
self.alive = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, handler):\n\n self.event_handler = handler",
"def _handler_init(self):\r\n\t\tself._handlers[\"player-join\"] = FunctionDelegate()\r\n\t\tself._handlers[\"player-quit\"] = FunctionDelegate()\r\n\t\tself._handlers[\"game-start\"] = FunctionDelegate()\r\n\t\tself._handlers[\"game-stop\"] ... | [
"0.79752",
"0.75133544",
"0.71794784",
"0.7137807",
"0.7092915",
"0.70223916",
"0.7013044",
"0.6823782",
"0.6721383",
"0.6712158",
"0.67117155",
"0.67050976",
"0.67050976",
"0.67050976",
"0.67050976",
"0.6701303",
"0.6639678",
"0.6624493",
"0.6624023",
"0.6623807",
"0.6576109... | 0.6113804 | 56 |
Distatches an event to any matching event handlers. The handler which specifically matches the event name will be called first, followed by any handlers with a 'match' method which matches the event name concatenated to the args string. | def dispatch(self, event, args=''):
try:
if event in self.events:
self.events[event](args)
for matcher, action in self.eventmatchers.iteritems():
ary = matcher.match(' '.join((event, args)))
if ary is not None:
action(*a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_handlers(self, event, method=EVENT_CAPTURE):\n if event not in self.events:\n return None\n for handler in self.events[str(event)].with_method(method):\n handler(event)",
"def onEvent(self, event):\n if event is None:\n return\n\n target_class ... | [
"0.6142079",
"0.6090708",
"0.58892405",
"0.57285976",
"0.56782824",
"0.56358707",
"0.56105155",
"0.5587811",
"0.5533092",
"0.55268854",
"0.54496866",
"0.541662",
"0.5377691",
"0.53475493",
"0.53425974",
"0.5300932",
"0.52983147",
"0.5238735",
"0.5219943",
"0.52198094",
"0.515... | 0.73175037 | 0 |
Enters the event loop, reading lines from wmii's '/event' and dispatching them, via dispatch, to event handlers. Continues so long as alive is True. | def loop(self):
keys.mode = 'main'
for line in client.readlines('/event'):
if not self.alive:
break
self.dispatch(*line.split(' ', 1))
self.alive = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run():\n\n while True:\n\n # get event, blah\n event_name, event_data = revent.get_event(block=True, timeout=5)\n\n if event_name is not None:\n print 'received: %s' % event_name\n\n if event_name.endswith('_oembed_details'):\n handle_new_oembed_deta... | [
"0.6532273",
"0.64159447",
"0.61325336",
"0.6103995",
"0.6085888",
"0.60446244",
"0.60411006",
"0.600487",
"0.59969455",
"0.5978081",
"0.5910201",
"0.5910201",
"0.59055114",
"0.5898839",
"0.5848962",
"0.5841019",
"0.5816226",
"0.5811897",
"0.580067",
"0.5787875",
"0.57788646"... | 0.7531345 | 0 |
Binds a number of event handlers for wmii events. Keyword arguments other than 'items' are added to the 'items' dict. Handlers are called by loop when a matching line is read from '/event'. Each handler is called with, as its sole argument, the string read from /event with its first token stripped. | def bind(self, items={}, **kwargs):
kwargs.update(items)
for k, v in flatten(kwargs.iteritems()):
if hasattr(k, 'match'):
self.eventmatchers[k] = v
else:
self.events[k] = v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _register_handlers(self):\n self.jm.register_handler(\"move_node\", self.move_node)\n self.jm.register_handler(\"copy_node\", self.copy_node)\n self.jm.register_handler(\"push_to_vospace\", self.push_to_vospace)\n self.jm.register_handler(\"push_from_vospace\", self.push_from_vospace)\n self.jm.... | [
"0.55518967",
"0.5541481",
"0.55277866",
"0.5482645",
"0.54119766",
"0.538342",
"0.5349072",
"0.5295835",
"0.5283326",
"0.5205757",
"0.51651305",
"0.5116842",
"0.5108721",
"0.5076696",
"0.5072107",
"0.5070965",
"0.5070048",
"0.5055877",
"0.5042442",
"0.5040995",
"0.50364155",... | 0.66373867 | 0 |
A decorator which binds its wrapped function, as via bind, for the event which matches its name. | def event(self, fn):
self.bind({fn.__name__: fn}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def binds(**binds):\n def decorate(func):\n function = to_function(func)\n setattr(function, BINDS, binds)\n return function\n return decorate",
"def bindEvent(obj, name, method):\n setattr(obj, name,\n types.MethodType(method, obj, obj.__class__))",
"def _event_bridge(... | [
"0.66477215",
"0.66141915",
"0.6544321",
"0.64554435",
"0.643344",
"0.6340396",
"0.6323057",
"0.6308433",
"0.61923933",
"0.6147095",
"0.6073753",
"0.601856",
"0.60135686",
"0.59841114",
"0.5885072",
"0.58757806",
"0.5850867",
"0.577973",
"0.577973",
"0.577973",
"0.577973",
... | 0.6808041 | 0 |
Initializes the class and binds an event handler for the Key event, as via pygmi.event.events.bind. Takes no arguments. | def __init__(self):
self.modes = {}
self.modelist = []
self.mode = 'main'
self.defs = {}
events.bind(Key=self.dispatch) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.key_handler = None",
"def __init__(self, graphics_controller):\n super(KeyHandler, self).__init__()\n self._key_handler = window.key.KeyStateHandler()\n self._key_release_mappings = {}\n self._key_press_mappings = {}\n self._key_down_mappings =... | [
"0.7799291",
"0.76643276",
"0.7037556",
"0.6991816",
"0.6635645",
"0.64325315",
"0.641163",
"0.63868123",
"0.63638663",
"0.6272472",
"0.6267949",
"0.6232856",
"0.6226452",
"0.6212436",
"0.6197106",
"0.6122265",
"0.6109509",
"0.60778034",
"0.6074329",
"0.6068947",
"0.6043387",... | 0.5398831 | 98 |
Binds a series of keys for the given 'mode'. Keys may be specified as a dict or as a sequence of tuple values and strings. In the latter case, documentation may be interspersed with key bindings. Any value in the sequence which is not a tuple begins a new key group, with that value as a description. A tuple with two va... | def bind(self, mode='main', keys=(), import_={}):
self._add_mode(mode)
mode = self.modes[mode]
group = None
def add_desc(key, desc):
if group not in mode['desc']:
mode['desc'][group] = []
mode['groups'].append(group)
if key not in m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bind_modifiers(widget, event:Callable, button='Button-1',\n modes=frozendict({'Shift': KeyModes.SHIFT, 'Control': KeyModes.CONTROL, 'Alt': KeyModes.ALT, })):\n widget.bind(button, event)\n for modifier, keymode in modes.items():\n # We must provide 'keymode' as a default argument... | [
"0.58895165",
"0.58841205",
"0.5588694",
"0.52264315",
"0.48822513",
"0.4842393",
"0.48337808",
"0.48153064",
"0.4735098",
"0.4661002",
"0.45969185",
"0.45763007",
"0.45294526",
"0.4502729",
"0.45009285",
"0.4483334",
"0.44517758",
"0.44213554",
"0.44187143",
"0.4397471",
"0.... | 0.7402634 | 0 |
Dispatches a key event for the current mode. | def dispatch(self, key):
mode = self.modes[self.mode]
if key in self._keys:
return self._keys[key](key) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def key_event(self, key: Any, action: Any):\n pass",
"def on_key_event(self, key):\n pass",
"def keyevent(self, keyname):\n self.adb.key_events(keyname)",
"def _on_key_press(self, event):",
"def key_press_event(self, event):\n pass",
"def keyevent(self, keycode: Union[str, int... | [
"0.7376395",
"0.7147326",
"0.70135456",
"0.69450104",
"0.6931355",
"0.67966765",
"0.67913014",
"0.674432",
"0.67261076",
"0.670082",
"0.66877836",
"0.6589483",
"0.6579696",
"0.65288365",
"0.63956237",
"0.63932157",
"0.6381464",
"0.63638973",
"0.6341006",
"0.63334644",
"0.6283... | 0.63129103 | 20 |
Calls a method named for the first token of 'args', with the rest of the string as its first argument. If the method doesn't exist, a trailing underscore is appended. | def _call(self, args):
a = args.split(' ', 1)
if a:
getattr(self, a[0])(*a[1:]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _func_named(self, arg):\n result = None\n target = 'do_' + arg\n if target in dir(self):\n result = target\n else:\n if self.abbrev: # accept shortened versions of commands\n funcs = [func for func in self.keywords if func.startswith(arg) and fu... | [
"0.61590546",
"0.61256295",
"0.60179985",
"0.5816926",
"0.5688947",
"0.5648416",
"0.5534845",
"0.5470439",
"0.53763974",
"0.53491557",
"0.5341609",
"0.5332069",
"0.5326649",
"0.53201157",
"0.53159",
"0.5265616",
"0.52220535",
"0.5211293",
"0.5182447",
"0.5174981",
"0.5169188"... | 0.75629675 | 0 |
Be sure to set_api_access_keys() before instantiating. | def __init__(self):
super().__init__()
self._api_url = API_BASE_URL
self._api_params = API_BASE_PARAMS.copy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.api = Api(consumer_key=credentials[\"consumer_key\"],\n consumer_secret=credentials[\"consumer_secret\"],\n access_token_key=credentials[\"access_token_key\"],\n access_token_secret=credentials[\"access_token_secret... | [
"0.77924526",
"0.7500983",
"0.7340485",
"0.73025846",
"0.72502905",
"0.71982646",
"0.7098907",
"0.7096858",
"0.70858496",
"0.70240563",
"0.7018257",
"0.69951254",
"0.69625777",
"0.6959681",
"0.6918534",
"0.6896694",
"0.68868685",
"0.6880991",
"0.6843295",
"0.68017286",
"0.678... | 0.6549042 | 30 |
Set the access key as key=your_googlemaps_key. This must be called prior to contacting the API. | def set_api_access_keys(**kwargs):
API_BASE_PARAMS['key'] = kwargs['key'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SetAPIKey(self, api_key):\n self._api_key = api_key",
"def SetAPIKey(self, api_key):\n self._api_key = api_key",
"def SetAPIKey(self, api_key):\n self._analyzer.SetAPIKey(api_key)",
"def update_key(self, key):\n self._api_key = key",
"def api_key(self, api_key):\n\n self._api_key... | [
"0.6702951",
"0.6702951",
"0.64656013",
"0.63789594",
"0.63458663",
"0.63154477",
"0.62301403",
"0.62292933",
"0.62059003",
"0.61881185",
"0.60916674",
"0.60765517",
"0.5990251",
"0.5933332",
"0.58120465",
"0.5781521",
"0.57431203",
"0.57308316",
"0.5702196",
"0.56874853",
"0... | 0.6750033 | 0 |
API endpoint for this authority. | def api_url(self):
return self._api_url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authorization_url(self): # pragma: no cover\n raise NotImplementedError()",
"def GET(self, uri):\n content_type = negotiated_content_type(self.supported_types, self.default_content_type)\n def body(conn, cur):\n self.enforce_right('enumerate', uri)\n return web.ctx... | [
"0.62671196",
"0.6057594",
"0.60088485",
"0.59507054",
"0.5881676",
"0.58631366",
"0.58126146",
"0.5806165",
"0.5777628",
"0.57215625",
"0.57129526",
"0.5697795",
"0.56665105",
"0.56434846",
"0.56295764",
"0.561666",
"0.5612907",
"0.5591394",
"0.5573596",
"0.5548972",
"0.5542... | 0.0 | -1 |
GET params for querying this authority. | def api_params(self):
return self._api_params | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_params(self):\n return self.request._request.GET",
"def query_params(self):\n path = self._get_id_path('query_params')\n \n response = self._GET(path)\n self._set_attrs_to_values({'query_params': response})\n return response",
"def get_query_parameters(self):... | [
"0.75401735",
"0.73343045",
"0.66216785",
"0.64343256",
"0.6397734",
"0.6369969",
"0.636452",
"0.62071246",
"0.6189369",
"0.6189369",
"0.6173704",
"0.61640465",
"0.6163428",
"0.6163428",
"0.6163428",
"0.6111815",
"0.6105756",
"0.6103935",
"0.6103162",
"0.61027837",
"0.6080298... | 0.6037017 | 25 |
Prepare params for request processing. | def prep_latlng_params(self, lat, lng):
self._api_params['latlng'] = '{},{}'.format(lat, lng) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _prepare_param_dict(self, params_dict):\n return params_dict",
"def prepare_request_params(\n request_params: Dict, model_id: Text, model_data: Dict\n) -> Dict:\n request_params = correct_types(request_params, model_data[\"columns_data\"])\n if model_data[\"hashed_indexes\"]:\n request... | [
"0.7291471",
"0.7015459",
"0.68069166",
"0.6802409",
"0.6752121",
"0.67507726",
"0.6709695",
"0.66218567",
"0.6613305",
"0.65984374",
"0.6551313",
"0.6478149",
"0.64343166",
"0.6366063",
"0.6338962",
"0.63367856",
"0.6329537",
"0.62906367",
"0.62503916",
"0.61877495",
"0.6136... | 0.57774526 | 62 |
Process response from authority API and return a list of humanreadable addresses for any matches. Raise GeoAuthorityError with an appropriate message otherwise. | def parse_location_response(self, location_json):
street_addresses = []
try:
if location_json['status'] == 'ZERO_RESULTS':
return []
elif location_json['status'] != 'OK':
self.logger.error("Unexpected response status: %s", location_json['status'])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addresses(self):\n if 'Ward Matters' in self.topics or 'City Matters' in self.topics:\n stname_pattern = \"(\\S*[a-z]\\S*\\s){1,4}?\"\n sttype_pattern = \"(ave|blvd|cres|ct|dr|hwy|ln|pkwy|pl|plz|rd|row|sq|st|ter|way)\"\n st_pattern = stname_pattern + sttype_pattern\n\n ... | [
"0.5419127",
"0.52974874",
"0.5250207",
"0.5239093",
"0.520853",
"0.5162842",
"0.51276225",
"0.5108789",
"0.5096379",
"0.50797266",
"0.5039929",
"0.50187445",
"0.5002884",
"0.49940777",
"0.4963809",
"0.49536124",
"0.4948754",
"0.4948175",
"0.49268144",
"0.49164474",
"0.491495... | 0.6365182 | 0 |
Create a standard user from API data. | def test_ParseAlice(self):
user = User.parse_raw(ALICE)
# self.assertEqual(type(user), Person)
self.assertEqual(user.name, "Alice") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, data):\n # ensure 'create()' calls the specific 'create_user()' method\n # note that the 'data' gets validated\n user = get_user_model().objects.create_user(**data)\n return user",
"def build_user(data: Dict[Any, Any]) -> User:\n return User(**data)",
"def new_us... | [
"0.7272184",
"0.7248692",
"0.7137372",
"0.71049374",
"0.70871747",
"0.70839095",
"0.7054846",
"0.70189977",
"0.69869274",
"0.698114",
"0.6975453",
"0.6963538",
"0.6960373",
"0.69428647",
"0.6922325",
"0.6921075",
"0.69137937",
"0.6906702",
"0.69002455",
"0.6899626",
"0.687958... | 0.0 | -1 |
Create a bot user from API data. | def test_ParseBob(self):
user = User.parse_raw(BOB)
# self.assertEqual(type(user), Bot)
self.assertEqual(user.name, "Bob")
self.assertIsNone(user.avatar_url) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, data):\n data.pop('password_confirmation')\n try:\n availability = data.pop(\"availability\")\n babysitter = data.pop(\"user_bbs\")\n user = User.objects.create_user(**data, is_verified=False)\n if babysitter:\n bbs = Babysit... | [
"0.69522387",
"0.6850721",
"0.68193614",
"0.67524874",
"0.67413753",
"0.67329466",
"0.6725897",
"0.6702241",
"0.66996366",
"0.66741824",
"0.6669265",
"0.6663651",
"0.665581",
"0.66362035",
"0.6635299",
"0.6624163",
"0.66120404",
"0.6574128",
"0.6566255",
"0.6560375",
"0.65508... | 0.0 | -1 |
Save filtered sequences according the config file. | def initFilters(CONFIG):
#### String containing all the preLibraries file name
preLibraries = findFile("classification_result/prelibraries/TE", "*.fasta")
#### String containing all the preLibraries file name
noCatLibrarie = findFile("classification_result/prelibraries/", "noCat.fasta")
listPrelibraries = []
##... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def autoSaveFilter(filename):",
"def save_seqs_to_file(self):\n if self.blast_type == 'local':\n self.seq_file = os.path.join(self.cwd,\n 'db',\n \"{0}_seqs.fas\".format(self.gene_code))\n queryset = Sequ... | [
"0.64152855",
"0.6286579",
"0.5894759",
"0.56407",
"0.5635714",
"0.55958396",
"0.5578768",
"0.55047834",
"0.5474374",
"0.54623854",
"0.5290035",
"0.5289094",
"0.5287275",
"0.5285117",
"0.5277353",
"0.5270988",
"0.5270139",
"0.524332",
"0.5242166",
"0.5229969",
"0.5229448",
... | 0.0 | -1 |
Find files according a patern. Return a list with the absolute path of all the files name matching with the pattern. | def findFile(PATH, PATTERN):
#### find all the file located in the PATH corresponding to the PATTERN
findPattern = subprocess.Popen('find {path} -name "{pattern}" 2> /dev/null'.format(path=PATH, pattern=PATTERN), shell=True, stdout=subprocess.PIPE);
#### String containing all the path toward the file's name matching... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _recursive_file_search(self, path, pattern):\n matches = []\n for root, dirnames, filenames in os.walk(path):\n for filename in fnmatch.filter(filenames, pattern):\n matches.append(os.path.join(root, filename))\n\n return matches",
"def filesInDir(self, path=Non... | [
"0.8233165",
"0.81035763",
"0.8085928",
"0.7977863",
"0.7956181",
"0.7890348",
"0.78722256",
"0.7811613",
"0.7773806",
"0.77685827",
"0.776343",
"0.77626514",
"0.77465606",
"0.7745978",
"0.7734364",
"0.7721344",
"0.7684481",
"0.76727057",
"0.76706004",
"0.7608046",
"0.7600679... | 0.6989657 | 75 |
Creates the three final Libraries. | def createIntermediateLibraries(LISTPRELIBRARIES, DICOLIBRARIES, CONFIG, DICOFINALCLASSIF):
#### Parse all the intermediate libraries files
for preLibrary in LISTPRELIBRARIES:
#### Retrieve the final classification name of the ET from the file name
finalClassification = os.path.basename(preLibrary).split(".fasta"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createFinalLibraries(INTERMEDIATELIBRARIES, DICOLIBRARIES):\n\t#### Parse all the intermediate libraries files\n\tfor file in INTERMEDIATELIBRARIES:\n\t\tfileName = os.path.basename(file).split(\".fasta\")[0]\n\t\t#### Read and store the fasta sequences of the prelibraries\n\t\tsequences=readInput.readFasta(fi... | [
"0.7787591",
"0.61216825",
"0.59788126",
"0.5914733",
"0.5853105",
"0.5761492",
"0.5729343",
"0.57070595",
"0.5634071",
"0.5578847",
"0.5557914",
"0.55127",
"0.5486333",
"0.5457092",
"0.5417137",
"0.54008245",
"0.5397091",
"0.53696746",
"0.53682125",
"0.5365185",
"0.53581166"... | 0.6650628 | 1 |
Apply filters from the CONFIG file to creates the final libraries. | def applyFiltersForIntermediate(ID, SEQUENCES, FINALCLASSIFICATION, CONFIG, DICOLIBRARIES):
#### First we check if tools used to detect the TE are from the removedTool or the onlySelectedtools of the CONFIG file
#### Parse the dictionnary containing CONFIG information
for sortedOutput in CONFIG:
#### Look for te f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initFilters(CONFIG):\n\t#### String containing all the preLibraries file name\n\tpreLibraries = findFile(\"classification_result/prelibraries/TE\", \"*.fasta\")\n\n\t#### String containing all the preLibraries file name\n\tnoCatLibrarie = findFile(\"classification_result/prelibraries/\", \"noCat.fasta\")\n\n\t... | [
"0.7448421",
"0.6242831",
"0.61883074",
"0.59563917",
"0.59024584",
"0.586367",
"0.5610522",
"0.55952257",
"0.55162007",
"0.55046",
"0.5463773",
"0.54559755",
"0.5417708",
"0.5369826",
"0.535978",
"0.5357048",
"0.5344488",
"0.53367615",
"0.5319207",
"0.5308367",
"0.53061336",... | 0.5215383 | 32 |
Apply the cdhitest on all the intermediate Libraries. | def applyCDHIT(INTERMEDIATELIBRARIES):
#### Apply cd-hit-est for all the intermediate library
for file in INTERMEDIATELIBRARIES:
fileName = os.path.basename(file).split(".fasta")[0]
os.chdir("classification_result/intermediateLibraries/")
subprocess.call('cdhit-est -aS 0.9 -c 0.9 -g 1 -r 1 -i {input}.fasta -o {... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_c_extensions_import():\n import storm_analysis.dbscan.dbscan_c\n \n import storm_analysis.fista.fista_fft_c\n \n import storm_analysis.frc.frc_c\n \n import storm_analysis.L1H.homotopy_imagea_c\n\n import storm_analysis.rolling_ball_bgr.rolling_ball_lib_c\n\n import stor... | [
"0.5385712",
"0.53443336",
"0.51123476",
"0.51066065",
"0.5053206",
"0.504615",
"0.5035862",
"0.50291365",
"0.50230294",
"0.50175893",
"0.4983539",
"0.49827704",
"0.4977544",
"0.49708322",
"0.49618056",
"0.49440145",
"0.4931897",
"0.49209505",
"0.49121943",
"0.48950914",
"0.4... | 0.72149426 | 0 |
Add the id of the sequences onto the DICOLIBRARIES in order to know for which library a sequence will be saved. | def retriveFinalLibrarieSequences(INTERMEDIATELIBRARIES, CONFIG, DICOFINALCLASSIF, DICOLIBRARIES):
for file in INTERMEDIATELIBRARIES:
fileName = os.path.basename(file).split(".fasta")[0]
#### Read and store the fasta sequences of the prelibraries
sequences=readInput.readFasta(file)
for id in sequences:
if f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_libraries(self, a, lib):\n logging.debug(\"in save libraries\")\n self.libraries.append(lib)\n self.produce(\"library\", lib)",
"def unify_ids(pdbmodels, verbose=False):\n seq_dict = dict() # Dictionary where sequences are keys and ids are values\n if verbose:\n print(... | [
"0.5920078",
"0.55056554",
"0.5498205",
"0.54516554",
"0.54133874",
"0.53987515",
"0.5365269",
"0.53635937",
"0.535374",
"0.53380966",
"0.53376156",
"0.5309192",
"0.5291356",
"0.52258646",
"0.52134526",
"0.51988417",
"0.51759744",
"0.5173731",
"0.5173344",
"0.51603353",
"0.51... | 0.48564407 | 51 |
Apply filters from the CONFIG file to creates the final libraries. | def applyFiltersForFinales(ID, SEQUENCES, FINALCLASSIFICATION, CONFIG, SORTEDOUTPUT, DICOLIBRARIES):
#### First we check if tools used to detect the TE are from the removedTool or the onlySelectedtools of the CONFIG file
#### Look for te finalClassification corresponding to the sequence
if CONFIG[SORTEDOUTPUT]["fina... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initFilters(CONFIG):\n\t#### String containing all the preLibraries file name\n\tpreLibraries = findFile(\"classification_result/prelibraries/TE\", \"*.fasta\")\n\n\t#### String containing all the preLibraries file name\n\tnoCatLibrarie = findFile(\"classification_result/prelibraries/\", \"noCat.fasta\")\n\n\t... | [
"0.7449922",
"0.62407774",
"0.61889404",
"0.59549785",
"0.59027463",
"0.58631474",
"0.5609206",
"0.5593095",
"0.55149376",
"0.55030483",
"0.5462658",
"0.5454153",
"0.5419757",
"0.5368659",
"0.53600055",
"0.5356726",
"0.5343718",
"0.5336285",
"0.5318649",
"0.5306495",
"0.53061... | 0.0 | -1 |
Creates the three final Libraries. | def createFinalLibraries(INTERMEDIATELIBRARIES, DICOLIBRARIES):
#### Parse all the intermediate libraries files
for file in INTERMEDIATELIBRARIES:
fileName = os.path.basename(file).split(".fasta")[0]
#### Read and store the fasta sequences of the prelibraries
sequences=readInput.readFasta(file)
#### Save the ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createIntermediateLibraries(LISTPRELIBRARIES, DICOLIBRARIES, CONFIG, DICOFINALCLASSIF):\n\t#### Parse all the intermediate libraries files\n\tfor preLibrary in LISTPRELIBRARIES:\n\t\t#### Retrieve the final classification name of the ET from the file name\n\t\tfinalClassification = os.path.basename(preLibrary)... | [
"0.6650628",
"0.61216825",
"0.59788126",
"0.5914733",
"0.5853105",
"0.5761492",
"0.5729343",
"0.57070595",
"0.5634071",
"0.5578847",
"0.5557914",
"0.55127",
"0.5486333",
"0.5457092",
"0.5417137",
"0.54008245",
"0.5397091",
"0.53696746",
"0.53682125",
"0.5365185",
"0.53581166"... | 0.7787591 | 0 |
A new hash string should be 152 bytes long | def test_new(self):
self.assertEqual(len(p.new('foo')), 168) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_hash(self, long_url: str, hash_length: int):\n hasher = hashlib.md5(long_url.encode())\n bytes_hash = base64.urlsafe_b64encode(hasher.digest())[:hash_length]\n str_hash = bytes_hash.decode()\n return str_hash",
"def hash(plainString):\n result = plainString\n for i in r... | [
"0.740472",
"0.7184337",
"0.71324676",
"0.70474213",
"0.703812",
"0.70344573",
"0.6992879",
"0.6978821",
"0.69644725",
"0.6943878",
"0.6927374",
"0.6871",
"0.6799098",
"0.67813987",
"0.672294",
"0.67222166",
"0.6721005",
"0.6701401",
"0.669934",
"0.669934",
"0.6693836",
"0.... | 0.0 | -1 |
Gets sys.argv and expecting a = format. Prints usage on error or request. | def parse_args(default=defaults,extra_usage='',required=['root']):
vars = default
if len(sys.argv)<2:
usage("Error: You must at least pass the following arguments!\n%s\n%s"%(str(required),extra_usage))
#Some things someone may type to get help
if sys.argv[1] in ['-h','--help','hel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_usage(arg_processor):\n min_width = max(map(lambda x : len(x),\\\n arg_processor.program_arg_order + arg_processor.program_flag_order))\n print \"Usage: python {} \".format(sys.argv[0])\n print \"The following flags and arguments can be supplied:\"\n print \"Flags:\"\n for flag in a... | [
"0.6791781",
"0.6728012",
"0.6684721",
"0.66259867",
"0.65740335",
"0.65634924",
"0.651287",
"0.6476925",
"0.64419854",
"0.6423106",
"0.64119226",
"0.6408889",
"0.6356593",
"0.6337435",
"0.6331671",
"0.63285047",
"0.6319351",
"0.6319351",
"0.63117146",
"0.62988",
"0.62978756"... | 0.0 | -1 |
Return df with all enteries which df.query(pattern) match with removed | def remove(df, pattern):
return df[~df.index.isin(df.query(pattern).index)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prune(df, regex_list):\n for regex_pattern in regex_list:\n df = df[~df.case_action.str.contains(regex_pattern)]\n return df",
"def clean(df):",
"def filter_same_helix(df):\n helixpattern = re.compile(r\"\"\"^(..)\\w+\\s+\\1\"\"\")#For detecting same-helix contacts, the ones like 1.22x22 1.... | [
"0.67580104",
"0.61284876",
"0.59954125",
"0.5946802",
"0.5877959",
"0.5857522",
"0.5824286",
"0.57481945",
"0.57481945",
"0.5692505",
"0.56695396",
"0.5544663",
"0.55146563",
"0.5502974",
"0.54838765",
"0.54560864",
"0.54314256",
"0.5424039",
"0.5391558",
"0.53590816",
"0.53... | 0.7941567 | 0 |
get data for just one gene (assay) to closer inspect data | def get_detailed_ddct_data(self, assay):
df = self.ddct.query("Assay == '{}'".format(assay)).reset_index(drop=True)
return pandas.pivot_table(df, values=0, columns='time', index=['cell_line', 'treatment', 'replicate']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gene(self, idx):\r\n return self.genes[idx]",
"async def test_get_gene_from_ac(test_db):\n resp = await test_db.get_gene_from_ac(\"NC_000007.13\", 140453136, None)\n assert resp == [\"BRAF\"]\n\n resp = await test_db.get_gene_from_ac(\"NC_000007.14\", 140753336, None)\n assert resp == [\"B... | [
"0.6190661",
"0.60675555",
"0.60619366",
"0.58405983",
"0.5830618",
"0.5788245",
"0.5680454",
"0.568016",
"0.56783557",
"0.56729907",
"0.56712174",
"0.5638997",
"0.56313276",
"0.5628834",
"0.5569161",
"0.5562359",
"0.5537546",
"0.55343705",
"0.55274814",
"0.55243385",
"0.5518... | 0.0 | -1 |
Get fold change averaged data for gene. This is useful as it formats data for input into copasi | def get_data_copasi_style_d3ct(self, gene, cell_line='A', plot=False, new_name=None,
filename=None, indep_dct=None):
if gene not in self.genes:
raise ValueError('{} is not in list of genes "{}"'.format(gene, self.genes))
df = self.d3ct.query('cell_line == "{}" and Assay == "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_average(self):\n return _favg(self.load_samples)",
"def get_mean(self):\n mean = np.array(np.zeros((4,8)))\n for i,c in enumerate(self.cellLines):\n for j,l in enumerate(self.ligands):\n mean[i][j] = self.aucs[c][l]['mean']\n return mean",
"def mea... | [
"0.56925446",
"0.5640803",
"0.54428434",
"0.5386881",
"0.53427356",
"0.5342548",
"0.5336942",
"0.53117526",
"0.528858",
"0.5283458",
"0.5280344",
"0.5261843",
"0.52486813",
"0.5230886",
"0.5226844",
"0.52136445",
"0.51920736",
"0.51852506",
"0.5177504",
"0.51448035",
"0.51356... | 0.52104104 | 16 |
Get fold change averaged data for gene. This is useful as it formats data for input into copasi | def get_data_copasi_style_dct(self, gene, cell_line='A', plot=False, new_name=None,
filename=None, indep_dct=None):
if gene not in self.genes:
raise ValueError('{} is not in list of genes "{}"'.format(gene, self.genes))
treat = self.treatment_data.query('ce... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_average(self):\n return _favg(self.load_samples)",
"def get_mean(self):\n mean = np.array(np.zeros((4,8)))\n for i,c in enumerate(self.cellLines):\n for j,l in enumerate(self.ligands):\n mean[i][j] = self.aucs[c][l]['mean']\n return mean",
"def mea... | [
"0.5692266",
"0.5642145",
"0.5442966",
"0.5387502",
"0.53431314",
"0.5342711",
"0.5338354",
"0.53111",
"0.5289658",
"0.5284847",
"0.52795583",
"0.5262822",
"0.5248242",
"0.52306324",
"0.5225943",
"0.52127075",
"0.52108794",
"0.519317",
"0.51858854",
"0.5179068",
"0.51451385",... | 0.0 | -1 |
Split design by subexperiment (1, 2, 3) and create SubExperiment objects | def create_subexperiments(self):
subexperiments = {}
for label, df in self.design.groupby(level=0):
subexperiments[label] = SubExperiment(label, df.loc[label], self.root)
return subexperiments | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_expand_experiments():\n template_script = get_template_script()\n experiment_systems = utils.CombinatorialLeaf(['explicit-system', 'implicit-system', 'hydration-system'])\n template_script['experiments']['system'] = experiment_systems\n\n exp_builder = ExperimentBuilder(script=template_script,... | [
"0.573789",
"0.57144195",
"0.56194884",
"0.5434938",
"0.5363377",
"0.53393525",
"0.529092",
"0.5277947",
"0.5253223",
"0.5229658",
"0.5225851",
"0.5225829",
"0.5144398",
"0.51441",
"0.5116659",
"0.5102679",
"0.5095015",
"0.5081049",
"0.5081003",
"0.50729406",
"0.5070303",
"... | 0.7028728 | 0 |
For the time being this is TGF/baseline and control/baseline The choice of 0 or 96 will make a difference | def calculate_ddct(self, baseline_time=0):
if baseline_time == 0:
baseline = self.baseline_data['dct'][0]
elif baseline_time == 96:
baseline = self.baseline_data['dct'][96]
elif baseline_time == 'average':
baseline = (self.baseline_data['dct'][0] + self.bas... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getBaselineThresh(self):\n print('Calculating 10% baseline')\n self.baseline = obrienBaseline.obrienBaseline(\n self.d['dos1rate'], timeWidth=5.0, \n cadence=0.1)\n self.peak_std = ( (self.d['dos1rate'][self.peakInd]/10 - \n ... | [
"0.6402152",
"0.63455784",
"0.6005763",
"0.6003944",
"0.5723235",
"0.5581667",
"0.5507382",
"0.5504862",
"0.5464299",
"0.546274",
"0.5449123",
"0.53767866",
"0.5366525",
"0.53509873",
"0.5350085",
"0.53294504",
"0.5323279",
"0.53189623",
"0.5305675",
"0.5283922",
"0.5271367",... | 0.50264245 | 61 |
calculate time course ddct divided by treated ddct | def calculate_d3ct(self):
data = deepcopy(self.ddct)
data = data.set_index(['cell_line', 'replicate', 'Assay', 'time', 'treatment'])
control = data.query('treatment == "Control"')#.reset_index(drop=True)
tgfb = data.query('treatment == "TGFb"')#.reset_index(drop=True)
control.ind... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_ddct(self, baseline_time=0):\n\n if baseline_time == 0:\n baseline = self.baseline_data['dct'][0]\n\n elif baseline_time == 96:\n baseline = self.baseline_data['dct'][96]\n\n elif baseline_time == 'average':\n baseline = (self.baseline_data['dct']... | [
"0.59847087",
"0.58669096",
"0.57550395",
"0.57550395",
"0.5598215",
"0.5565188",
"0.5560319",
"0.5546098",
"0.55023235",
"0.5496921",
"0.5495189",
"0.5454725",
"0.5453212",
"0.53904337",
"0.53737885",
"0.5367238",
"0.5349814",
"0.53281",
"0.53280526",
"0.5322929",
"0.5310778... | 0.5310874 | 20 |
calculate time course ddct divided by treated ddct | def calculate_d4ct(self, pairs_dct=None):
#a, b, c, d, e, f, g, h, i
if pairs_dct is None:
pairs_dct={
'D': 'A',
'G': 'A',
'E': 'B',
'H': 'B',
'F': 'C',
'I': 'C',
}
data = deep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_ddct(self, baseline_time=0):\n\n if baseline_time == 0:\n baseline = self.baseline_data['dct'][0]\n\n elif baseline_time == 96:\n baseline = self.baseline_data['dct'][96]\n\n elif baseline_time == 'average':\n baseline = (self.baseline_data['dct']... | [
"0.59870166",
"0.58656496",
"0.57553",
"0.57553",
"0.55991685",
"0.5563111",
"0.5560583",
"0.5544466",
"0.55035794",
"0.54969424",
"0.54954",
"0.54544187",
"0.54526633",
"0.5389543",
"0.5374481",
"0.53677905",
"0.535153",
"0.5330187",
"0.53280985",
"0.5323999",
"0.53121424",
... | 0.0 | -1 |
get all the data, design plus raw plus normalized for subexperiment | def data(self):
return pandas.concat([i.data for i in list(self.plates.values())]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def datasets(self):\n pass",
"def getData(trainSize):\r\n return splitData([getReal(), getFake()], trainSize=trainSize)",
"def get_raw(data_folder, dataset_id, subject, stim_type=\"distress\"):\r\n\r\n if dataset_id in [\"raw_clean_32\"]: #two conditions experiments\r\n raw_0, raw_1, events... | [
"0.62828743",
"0.626822",
"0.6251617",
"0.62077177",
"0.6118616",
"0.608259",
"0.60632056",
"0.6046632",
"0.6015187",
"0.6005819",
"0.6002392",
"0.5981022",
"0.5975537",
"0.594545",
"0.59365",
"0.5932329",
"0.5926135",
"0.592105",
"0.5919021",
"0.58763653",
"0.58556014",
"0... | 0.56952274 | 46 |
Get a subset of the design. A nice method but not actually used elsewhere. | def get(self, query):
if not isinstance(query, dict):
raise ValueError('Query should be a python dict')
##set default query containing all values
default_query = {
'cell_id': self.cell_id,
'treatment': self.treatments,
'time_point': self.time_poi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_designs(self):",
"def subset(\n self, \n include: Union[Sequence[Any], Any] = None, \n exclude: Union[Sequence[Any], Any] = None) -> Bunch:\n pass",
"def default_subset(self):\n\t\treturn [slice(0,dim.length) for dim in self.variable.dimensions]",
"def get_subset(self, nam... | [
"0.64185005",
"0.6416632",
"0.62816876",
"0.60458934",
"0.60294616",
"0.59579057",
"0.5831714",
"0.5782122",
"0.57754046",
"0.5741057",
"0.5671157",
"0.56486607",
"0.56307197",
"0.5624579",
"0.56143534",
"0.56012255",
"0.555921",
"0.55588406",
"0.54997003",
"0.54997003",
"0.5... | 0.0 | -1 |
Organize chip into readings per sample | def samples(self):
sample = {}
for label, df in self.data.groupby(by='Sample'):
sample[label] = Sample(label, df)
return sample | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def samples(self):\n pass",
"def _read_cardiochip(self):\n cur_leadstatus = 0\n sample_count =0\n while self.connected:\n sample_count+=1\n #check for sync bytes\n readbyte = ord(self.ser.read(1))\n #print readbyte, SYNC_BYTE\n if... | [
"0.6005613",
"0.5774641",
"0.5711628",
"0.5686355",
"0.56711054",
"0.56303364",
"0.5627739",
"0.56075263",
"0.55885583",
"0.55885583",
"0.55640453",
"0.5494687",
"0.54919183",
"0.54767716",
"0.5444199",
"0.5424295",
"0.5424295",
"0.5423679",
"0.54222864",
"0.5411638",
"0.5382... | 0.0 | -1 |
Get baseline data without treatment time courses | def baseline(self):
return self.data[self.data['treatment'] == 'Baseline'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def emissions_baseline(self):\n baseline = DataFrame(columns=[\"CO2\", \"NOx\", \"PM10\", \"PM2.5\", \"SO2\"])\n baseline = baseline.append(year_1(self.plant.emissions()))\n baseline = baseline.append(year_1(self.plant.fuel_reseller().emissions()))\n baseline = baseline.append(year_1(se... | [
"0.661995",
"0.5938596",
"0.5920818",
"0.5673383",
"0.56499016",
"0.5554714",
"0.5551037",
"0.5503436",
"0.5422899",
"0.5406511",
"0.53813374",
"0.53646106",
"0.5344754",
"0.53437316",
"0.533326",
"0.5273145",
"0.52495307",
"0.5244175",
"0.5234559",
"0.5222947",
"0.5214892",
... | 0.61777115 | 1 |
Get treatment time courses without baseline data | def treatments(self):
return self.data[self.data['treatment'] != 'Baseline'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_timecourses(self):\n # load the timecourses file\n tcsf = fetch_one_file(self.ica_dir, self._tcs_fname)\n tcs = niimg.load_img(tcsf).get_data()\n return tcs",
"def _load_timecourses(self):\n # load the timecourses file\n tcsf = fetch_one_file(self.ica_dir, self... | [
"0.6250547",
"0.62290126",
"0.61140645",
"0.59820795",
"0.59133375",
"0.5577022",
"0.54320115",
"0.5422249",
"0.5395153",
"0.5357361",
"0.53467005",
"0.5322102",
"0.53120166",
"0.5310064",
"0.526714",
"0.5255139",
"0.5216506",
"0.51582277",
"0.5101761",
"0.5069965",
"0.505666... | 0.4884956 | 33 |
verify integrity of user input | def do_checks(self):
# ## get valid experiment variables
all_subexperiments = [1, 2, 3]
all_plates = list(range(1, 19))
all_cell_ids = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
all_samples = list(self.experiment.design['Sample'])
all_genes = self.experiment.subexperim... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_validity(self):",
"def isInputValid(self, input):\r\n pass",
"def validate():",
"def validate_input(self, *args):\n return",
"def verify():",
"def validate_user_input(user_input):\n responses = ['t', 'r', 'q']\n return user_input in responses",
"def test_valid_user_input(s... | [
"0.7332497",
"0.7278962",
"0.7278766",
"0.71752334",
"0.68487245",
"0.6826624",
"0.68062013",
"0.6788392",
"0.6787829",
"0.66582745",
"0.6449319",
"0.64325076",
"0.6425667",
"0.63953435",
"0.6345437",
"0.632387",
"0.6322956",
"0.6319321",
"0.6303776",
"0.62568563",
"0.6250406... | 0.0 | -1 |
Creates a millisecond based timestamp of UTC now. | def get_utc_now_timestamp() -> int:
return int(datetime.datetime.now(datetime.timezone.utc).timestamp() * 1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Now():\n ut = (datetime.datetime.utcnow() - _EPOCH).total_seconds() / 86400.0\n return Time(ut)",
"def now() -> datetime:\n now = datetime.now(tz=timezone.utc)\n return now.replace(microsecond=now.microsecond - now.microsecond % 1000)",
"def now_timestamp(unit: TimeUnit = TimeUn... | [
"0.7358585",
"0.73144686",
"0.73085713",
"0.7295754",
"0.72463673",
"0.719578",
"0.71388984",
"0.71132016",
"0.71132016",
"0.7087358",
"0.70538455",
"0.70202845",
"0.69747436",
"0.69600034",
"0.6942168",
"0.6916312",
"0.69006324",
"0.68955755",
"0.68503773",
"0.68242997",
"0.... | 0.7725665 | 0 |
Convert to the string in whiltespaceseparated tokens Addhoc addition. | def convert_pr_wvi_to_string(pr_wvi, nlu_t, nlu_wp_t, wp_to_wh_index, nlu):
pr_wv_str_wp = [] # word-piece version
pr_wv_str = []
for b, pr_wvi1 in enumerate(pr_wvi):
pr_wv_str_wp1 = []
pr_wv_str1 = []
wp_to_wh_index1 = wp_to_wh_index[b]
nlu_wp_t1 = nlu_wp_t[b]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_spaces(text):\n return \" \".join(text)",
"def _remove_extra_whitespaces(self, text: str) -> str:\n return re.sub(\" +\", \" \", text)",
"def wrapspace(text, token):\n\n # Wildcards have no whitespace. Need special case since * is also multiply which does have whitespace.\n if t... | [
"0.6040225",
"0.5965436",
"0.565226",
"0.55917454",
"0.5590612",
"0.5502032",
"0.54759145",
"0.54269254",
"0.5407506",
"0.537984",
"0.5370962",
"0.5360763",
"0.53585404",
"0.53528565",
"0.5322174",
"0.53027683",
"0.52994215",
"0.5293425",
"0.5283788",
"0.52749795",
"0.5263112... | 0.0 | -1 |
Almost copied of SQLNet. The main purpose is pad blank line while combining tokens. | def merge_wv_t1_eng(where_str_tokens, NLq):
nlq = NLq.lower()
where_str_tokens = [tok.lower() for tok in where_str_tokens]
alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789$'
special = {'-LRB-': '(',
'-RRB-': ')',
'-LSB-': '[',
'-RSB-': ']',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _output_padding_line(self):\n for i in range(self.num_new_columns):\n self._write_column(self.new_columns[i], '|')\n self.buf += ' '\n\n self._pad_horizontally(self.num_new_columns * 2)",
"def rehydrate_blank_line(cls, next_token):\n return next_token.extracted_whit... | [
"0.6392049",
"0.6164877",
"0.60053855",
"0.5916133",
"0.5909493",
"0.5903229",
"0.57719034",
"0.5734293",
"0.57243377",
"0.56752753",
"0.5638436",
"0.5602468",
"0.5591528",
"0.55746096",
"0.5573323",
"0.55722106",
"0.55722106",
"0.55722106",
"0.5568011",
"0.549426",
"0.549023... | 0.0 | -1 |
usalbe only when g_wc was used to find pr_wv | def get_cnt_sw_list(g_sc, g_sa, g_wn, g_wc, g_wo, g_wvi,
pr_sc, pr_sa, pr_wn, pr_wc, pr_wo, pr_wvi,
g_sql_i, pr_sql_i,
mode):
cnt_sc = get_cnt_sc_list(g_sc, pr_sc)
cnt_sa = get_cnt_sc_list(g_sa, pr_sa)
cnt_wn = get_cnt_sc_list(g_wn, pr_wn)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode):\r\n cnt_list =[]\r\n for b, g_wc1 in enumerate(g_wc):\r\n pr_wn1 = len(pr_sql_i[b][\"conds\"])\r\n g_wn1 = g_wn[b]\r\n\r\n # Now sorting.\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx1 = arg... | [
"0.5783301",
"0.5585813",
"0.54354393",
"0.5363023",
"0.5359201",
"0.5240661",
"0.52019274",
"0.5175359",
"0.5097325",
"0.5092165",
"0.5047512",
"0.5047512",
"0.5047512",
"0.5030539",
"0.50301886",
"0.50111204",
"0.5002621",
"0.4978421",
"0.49574295",
"0.49345815",
"0.4929732... | 0.49491084 | 19 |
pr's are all sorted as pr_wc are sorted in increasing order (in column idx) However, g's are not sorted. Sort g's in increasing order (in column idx) | def get_cnt_wo_list(g_wn, g_wc, g_wo, pr_wc, pr_wo, mode):
cnt_list=[]
for b, g_wo1 in enumerate(g_wo):
g_wc1 = g_wc[b]
pr_wc1 = pr_wc[b]
pr_wo1 = pr_wo[b]
pr_wn1 = len(pr_wo1)
g_wn1 = g_wn[b]
if g_wn1 != pr_wn1:
cnt_list.append(0)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sort(self):\n self.rows.sort(key=lambda x: (x['PERC1'], x['EQ'], x['PASS'], x['W2']),\n reverse=True)\n\n rank = 0\n prev_perc = 0\n prev_rank = 0\n for row in self.rows:\n if row[\"NR\"] == 0:\n # Something has already populat... | [
"0.6440761",
"0.6183674",
"0.58891386",
"0.5887252",
"0.5864489",
"0.5768664",
"0.5755941",
"0.5731223",
"0.5588322",
"0.55396104",
"0.5513205",
"0.54945284",
"0.5487258",
"0.54705155",
"0.54693717",
"0.5463505",
"0.5420143",
"0.5404942",
"0.5398548",
"0.538597",
"0.53687453"... | 0.0 | -1 |
usalbe only when g_wc was used to find pr_wv | def get_cnt_wvi_list(g_wn, g_wc, g_wvi, pr_wvi, mode):
cnt_list =[]
for b, g_wvi1 in enumerate(g_wvi):
g_wc1 = g_wc[b]
pr_wvi1 = pr_wvi[b]
pr_wn1 = len(pr_wvi1)
g_wn1 = g_wn[b]
# Now sorting.
# Sort based wc sequence.
if mode == 'test':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode):\r\n cnt_list =[]\r\n for b, g_wc1 in enumerate(g_wc):\r\n pr_wn1 = len(pr_sql_i[b][\"conds\"])\r\n g_wn1 = g_wn[b]\r\n\r\n # Now sorting.\r\n # Sort based wc sequence.\r\n if mode == 'test':\r\n idx1 = arg... | [
"0.57836646",
"0.5585155",
"0.5435751",
"0.53624374",
"0.53587824",
"0.5239644",
"0.5201019",
"0.517548",
"0.50928926",
"0.5047328",
"0.5047328",
"0.5047328",
"0.50309426",
"0.5029931",
"0.5010414",
"0.50012654",
"0.4978423",
"0.49580443",
"0.4950043",
"0.49334282",
"0.492841... | 0.50977534 | 8 |
usalbe only when g_wc was used to find pr_wv | def get_cnt_wv_list(g_wn, g_wc, g_sql_i, pr_sql_i, mode):
cnt_list =[]
for b, g_wc1 in enumerate(g_wc):
pr_wn1 = len(pr_sql_i[b]["conds"])
g_wn1 = g_wn[b]
# Now sorting.
# Sort based wc sequence.
if mode == 'test':
idx1 = argsort(array(g_wc1))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_wo(self):\n self.uom_id = self.wo_id.uom_id.id\n self.final_product_id = self.wo_id.final_product_id.id\n if not self.supplier_id:\n self.service_ids = [x.product_id.id for x in self.wo_id.consumed_service_ids if x.product_id]\n else:\n service_ids = [... | [
"0.5585714",
"0.54342604",
"0.5361827",
"0.5358429",
"0.5239973",
"0.51996017",
"0.51747024",
"0.50968176",
"0.50909096",
"0.5046365",
"0.5046365",
"0.5046365",
"0.5030739",
"0.50290895",
"0.50091815",
"0.5000712",
"0.49765882",
"0.49565095",
"0.4948263",
"0.4933547",
"0.4929... | 0.57827145 | 0 |
master monitor is running or not | def is_running(ssh):
if get_status(ssh) == "running":
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self):\n status = self.os.popen('circusctl status monitor').read().strip()\n\n if status == 'active':\n return True\n elif status == 'stopped':\n return False",
"def is_master(self):\n return MPControl.is_master",
"def slave_status():\n run_mysq... | [
"0.76096",
"0.71582156",
"0.69318926",
"0.68682814",
"0.67281044",
"0.6716801",
"0.669943",
"0.6669908",
"0.66140735",
"0.66064215",
"0.6597562",
"0.659302",
"0.6580973",
"0.6576386",
"0.6575719",
"0.6559207",
"0.65534914",
"0.65473324",
"0.6541179",
"0.651523",
"0.64646703",... | 0.61071116 | 59 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.