0:\\r\\n if item[0] == \\\"SPECGRID\\\":\\r\\n self.SPECGRID = np.array(fp.readline().split()[0:3], dtype=int)\\r\\n if item[0] == \\\"COORDSYS\\\":\\r\\n self.COORDSYS = fp.readline().split()\\r\\n if item[0] == \\\"COORD\\\":\\r\\n break\\r\\n\\r\\n # Read in the coordinates\\r\\n self.coords = []\\r\\n for line in fp:\\r\\n if line.split()[-1] != \\\"/\\\":\\r\\n item = line.split()\\r\\n for c in item:\\r\\n if '*' in c:\\r\\n cc = c.split('*')\\r\\n for i in range(int(cc[0])):\\r\\n self.coords.append(cc[-1])\\r\\n else:\\r\\n self.coords.append(c)\\r\\n else:\\r\\n if len(line.split()) > 1:\\r\\n item = line.split()\\r\\n for i in range(len(item) - 1):\\r\\n cc = item[i]\\r\\n if '*' in cc:\\r\\n ccc = cc.split('*')\\r\\n for j in range(int(ccc[0])):\\r\\n self.coords.append(ccc[-1])\\r\\n else:\\r\\n self.coords.append(c)\\r\\n break\\r\\n else:\\r\\n break\\r\\n\\r\\n # Read in ZCORN\\r\\n self.zcorn = []\\r\\n i = 0\\r\\n for line in fp:\\r\\n item = line.split()\\r\\n if len(item) > 0:\\r\\n if item[0] == \\\"ZCORN\\\":\\r\\n for line in fp:\\r\\n if line.split():\\r\\n if line.split()[-1] != \\\"/\\\":\\r\\n self.zcorn += line.split()\\r\\n else:\\r\\n self.zcorn += line.split()[0:-1]\\r\\n break\\r\\n if len(self.zcorn) > 0:\\r\\n break\\r\\n\\r\\n # Read in (in)active cells\\r\\n self.active = []\\r\\n for line in fp:\\r\\n item = line.split()\\r\\n if len(item) > 0:\\r\\n if item[0] == \\\"ACTNUM\\\":\\r\\n for line in fp:\\r\\n if line.split():\\r\\n if line.split()[-1] != \\\"/\\\":\\r\\n c = line.split()\\r\\n if '*' in c:\\r\\n cc = c.split('*')\\r\\n for i in range(float(cc[0])):\\r\\n self.active += cc[-1]\\r\\n else:\\r\\n self.active += c\\r\\n else:\\r\\n self.active += line.split()[0:-1]\\r\\n break\\r\\n\\r\\n self.coords = np.array(self.coords, dtype=float)\\r\\n print(self.coords)\\r\\n\\r\\n # In Petrel...\\r\\n self.ne = self.SPECGRID[0] # x i\\r\\n self.nn = self.SPECGRID[1] # y j\\r\\n self.nz = self.SPECGRID[2] # z k\\r\\n\\r\\n # build grid\\r\\n self.buildGrid(plot=False)\\r\\n self.buildActiveCells(plot=False)\\r\\n self.buildZGrid(plot=False)\\r\\n # self.calculateVolumes(plot=False)\\r\\n #\\r\\n # Convert to VTK\\r\\n self.GridType = \\\"vtkStructuredGrid\\\"\\r\\n self.Grid = vtk.vtkStructuredGrid()\\r\\n self.Grid.SetDimensions(self.ne+1, self.nn+1, self.nz+1)\\r\\n vtk_points = vtk.vtkPoints()\\r\\n ve = 1.\\r\\n\\r\\n for iz in range(self.nz):\\r\\n if iz == 0:\\r\\n for iy in range(self.nn+1):\\r\\n for ix in range(self.ne+1):\\r\\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\\\\r\\n self.Y0[ix,iy], \\\\\\r\\n ve * self.ZZT[iz][ix,iy] )\\r\\n for iy in range(self.nn+1):\\r\\n for ix in range(self.ne+1):\\r\\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\\\\r\\n self.Y0[ix,iy], \\\\\\r\\n ve * self.ZZB[iz][ix,iy] )\\r\\n self.Grid.SetPoints(vtk_points)\\r\\n\\r\\n # Add in active cells\\r\\n ac = vtk.vtkIntArray()\\r\\n ac.SetName( \\\"ActiveCells\\\" )\\r\\n for iac in self.ActiveCells.flatten( order='F' ):\\r\\n ac.InsertNextTuple1( iac )\\r\\n self.Grid.GetCellData().AddArray(ac)\",\n \"def import_texture(self, texture):\\n logger.debug((\\\"texture\\\", texture))\\n if texture in self._imported_assets:\\n return self._imported_assets[texture]\\n else:\\n texture = texture.decode()\\n tex = self.gridinfo.getAsset(texture)\\n if \\\"name\\\" in tex:\\n tex_name = tex[\\\"name\\\"]\\n try:\\n btex = bpy.data.textures[tex_name]\\n # XXX should update\\n return btex\\n except:\\n dest = self.decode_texture(texture, tex_name, tex[\\\"data\\\"])\\n self.parse_texture(texture, tex_name, dest)\",\n \"def load_ccs9():\\n ccs9 = pd.read_csv(pkg_resources.resource_filename(__name__,'$dxref 2015.csv'))\\n ccs9 = ccs9.reset_index()\\n for col in ccs9.columns:\\n ccs9.loc[:,col]=ccs9[col].str.strip('\\\\'')\\n ccs9.columns=ccs9.iloc[0,:]\\n ccs9 = ccs9.iloc[1:,:]\\n ccs9 = ccs9.replace(r'^\\\\s*$', np.nan, regex=True)\\n ccs9 = ccs9.loc[ccs9['ICD-9-CM CODE'].notnull(),:]\\n ccs9.loc[:,'ICD-9-CM CODE'] = ccs9['ICD-9-CM CODE'].str.replace(' ','')\\n ccs9.loc[:,'CCS CATEGORY'] = ccs9['CCS CATEGORY'].str.replace(' ','')\\n ccs9 = ccs9.iloc[:,0:4] \\n ccs9_labels = pd.read_csv(pkg_resources.resource_filename(__name__,'dxlabel 2015.csv'))\\n ccs9 = ccs9.merge(ccs9_labels,how='left',left_on='CCS CATEGORY',right_on='CCS DIAGNOSIS CATEGORIES')\\n ccs9.drop('CCS CATEGORY DESCRIPTION',axis=1,inplace=True)\\n ccs9.drop('CCS DIAGNOSIS CATEGORIES',axis=1,inplace=True)\\n ccs9.columns = [i.replace('CCS DIAGNOSIS CATEGORIES LABELS','CCS CATEGORY DESCRIPTION') for i in ccs9.columns]\\n return ccs9\",\n \"def load(self):\\n\\n # Set Environment Settings\\n arcpy.env.workspace = f\\\"{self.config_dict.get('proj_dir')}\\\"\\n arcpy.env.overwriteOutput = True\\n\\n in_table = r\\\"C:\\\\Users\\\\chica\\\\Documents\\\\ArcGIS\\\\Projects\\\\WNVOutbreak\\\\new_addresses.csv\\\"\\n out_feature_class = f\\\"{self.config_dict.get('proj_dir')}WNVOutbreak.gdb\\\\\\\\avoid_points\\\"\\n print(f\\\"{out_feature_class}\\\")\\n print(\\\"Avoid points file has been created.\\\")\\n x_coords = \\\"X\\\"\\n y_coords = \\\"Y\\\"\\n\\n # Make the XY event layer using arcpy's XYTabletoPoint function.\\n arcpy.management.XYTableToPoint(in_table, out_feature_class, x_coords, y_coords)\\n\\n # Print the total rows\\n print(arcpy.GetCount_management(out_feature_class))\",\n \"def import_cclib(self, fname):\\n try:\\n self.ftype = 'cclib'\\n data = cclib.io.ccread(fname)\\n self.n_atom = data.natom\\n self.at_num = data.atomnos\\n # This gets the atomic symbols by looking up the keys of the\\n # atomic numbers. It looks somewhat crazy but it is looking\\n # through a list of the values stored in the dictionary,\\n # matching the value to the atomic number and returning\\n # the key that corresponds to that atomic number. It works\\n # with this dictionary because the keys to values are 1 to 1.\\n self.sym = []\\n for i in data.atomnos:\\n self.sym.append(qcel.periodictable.to_E(i))\\n # cclib stores the atomic coordinates in a array of shape\\n # [molecule, num atoms, 3 for xyz] because I think they might\\n # have many \\\"molecules\\\" from each step of an optimization or\\n # something. Here we are taking just the last one.\\n self.xyz = data.atomcoords[-1]\\n return True\\n except:\\n return False\",\n \"def load_oned(self):\\n self.od=self.data1(\\\"xgc.oneddiag.bp\\\") #actual reading routine\\n self.od.psi=self.od.psi[0,:]\\n self.od.psi00=self.od.psi00[0,:]\\n try:\\n self.od.psi00n=self.od.psi00/self.psix #Normalize 0 - 1(Separatrix)\\n except:\\n print(\\\"psix is not defined - call load_unitsm() to get psix to get psi00n\\\")\\n # Temperatures\\n try: \\n Teperp=self.od.e_perp_temperature_df_1d\\n except:\\n print('No electron')\\n self.electron_on=False\\n else:\\n self.electron_on=True\\n Tepara=self.od.e_parallel_mean_en_df_1d #parallel flow ignored, correct it later\\n self.od.Te=(Teperp+Tepara)/3*2\\n Tiperp=self.od.i_perp_temperature_df_1d\\n Tipara=self.od.i_parallel_mean_en_df_1d #parallel flow ignored, correct it later\\n self.od.Ti=(Tiperp+Tipara)/3*2\\n\\n #ExB shear calculation\\n if(self.electron_on):\\n shear=self.od.d_dpsi(self.od.e_poloidal_ExB_flow_1d,self.od.psi_mks)\\n self.od.grad_psi_sqr = self.od.e_grad_psi_sqr_1d\\n else:\\n shear=self.od.d_dpsi(self.od.i_poloidal_ExB_flow_1d,self.od.psi_mks)\\n self.od.grad_psi_sqr = self.od.i_grad_psi_sqr_1d\\n self.od.shear_r=shear * np.sqrt(self.od.grad_psi_sqr) # assuming electron full-f is almost homogeneouse\\n\\n if(self.electron_on):\\n self.od.density = self.od.e_gc_density_df_1d\\n else:\\n self.od.density = self.od.i_gc_density_df_1d\\n\\n #gradient scale\\n self.od.Ln = self.od.density / self.od.d_dpsi(self.od.density, self.od.psi_mks) / np.sqrt(self.od.grad_psi_sqr)\\n self.od.Lti =self.od.Ti / self.od.d_dpsi(self.od.Ti , self.od.psi_mks) / np.sqrt(self.od.grad_psi_sqr)\\n if(self.electron_on):\\n self.od.Lte =self.od.Te / self.od.d_dpsi(self.od.Te , self.od.psi_mks) / np.sqrt(self.od.grad_psi_sqr)\\n \\n\\n #find tmask\\n d=self.od.step[1]-self.od.step[0]\\n st=self.od.step[0]/d\\n ed=self.od.step[-1]/d\\n st=st.astype(int)\\n ed=ed.astype(int)\\n idx=np.arange(st,ed, dtype=int)\\n\\n self.od.tmask=idx #mem allocation\\n for i in idx:\\n tmp=np.argwhere(self.od.step==i*d)\\n #self.od.tmask[i-st/d]=tmp[-1,-1] #LFS zero based, RHS last element\\n self.od.tmask[i-st]=tmp[-1,-1] #LFS zero based, RHS last element\",\n \"def insert_user_bar_lib(note, path_ex_folder):\\n user_bar_lib = open(PATH_UTILS + 'user_bar.py', 'r', encoding='utf-8').read()\\n\\n pattern = re.compile(\\\"^esame_RO-[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]_id\\\")\\n absolute_path_dirs_array = path_ex_folder.split('/')\\n pos = None\\n for i,dir in zip(range(len(absolute_path_dirs_array)), absolute_path_dirs_array):\\n if pattern.match(absolute_path_dirs_array[i]):\\n pos = i\\n assert pos != None\\n note['cells'] += [nb.v4.new_code_cell(user_bar_lib.replace('@path_ex_folder@',\\\".../\\\" + '/'.join(absolute_path_dirs_array[pos:])))]\\n\\n note.cells[-1].metadata = {\\\"init_cell\\\": True, \\\"editable\\\": False, \\\"deletable\\\": False, \\\"tags\\\": ['run_start']}\\n return\",\n \"def _load( self, i ):\\n if ir.config.verbosity_level >= 2: print(\\\"[observation] Lazy loading raster\\\")\\n self._raster_data[i] = raster_cube( self._raster_files, line=self._line_info['description'][i], keep_null=self._keep_null )\",\n \"def find_load_magics_in_cell(cell):\\n load_magics = []\\n for cell_source_line in cell['source']:\\n m = re.match('#\\\\s?%load.*', cell_source_line)\\n if m:\\n load_magics.append(m.group())\\n return load_magics\",\n \"def _load_chan(chan):\\n # Load the coordinates template :\\n path = sys.modules[__name__].__file__.split('objects')[0]\\n path = os.path.join(path, 'topo')\\n file = np.load(os.path.join(path, 'eegref.npz'))\\n nameRef, xyzRef = file['chan'], file['xyz']\\n keeponly = np.ones((len(chan)), dtype=bool)\\n # nameRef = list(nameRef)\\n # Find and load xyz coordinates :\\n xyz = np.zeros((len(chan), 3), dtype=np.float32)\\n for num, k in enumerate(chan):\\n # Find if the channel is present :\\n idx = np.where(nameRef == k)[0]\\n if idx.size:\\n xyz[num, 0:2] = np.array(xyzRef[idx[0], :])\\n else:\\n keeponly[num] = False\\n\\n return np.array(xyz), keeponly\",\n \"def ImportCore():\\n import ycm_core as ycm_core\\n return ycm_core\",\n \"def load_data_from_offset(reader, offset, is_file = True, nk_partial = False):\\n\\t\\tif is_file is True:\\n\\t\\t\\treader.seek(4096+offset,0)\\n\\t\\telse:\\n\\t\\t\\treader.seek(offset,0)\\n\\t\\tcell = NTRegistryCell.read(reader, nk_partial = nk_partial)\\n\\t\\treturn cell.data\",\n \"def __init__(self, name=None, compile_paths=combined_path):\\n Hay2011Cell.__init__(self, name=name, compile_paths=compile_paths)\",\n \"def from_spreadsheet(spreadsheet, framework):\\n\\n # Basically the strategy is going to be\\n # 1. Read in all of the stuff - pops, transfers, interpops can be directly added to Data\\n # 2. Read in all the other TDVE content, and then store it in the data specs according to the variable type defined in the Framework\\n # e.g. the fact that 'Alive' is a Characteristic is stored in the Framework and Data but not in the Databook. So for example, we read in\\n # a TDVE table called 'Alive', but it needs to be stored in data.specs['charac']['ch_alive'] and the 'charac' and 'ch_alive' are only available in the Framework\\n\\n import openpyxl\\n\\n self = ProjectData(framework=framework)\\n\\n if not isinstance(spreadsheet, sc.Spreadsheet):\\n spreadsheet = sc.Spreadsheet(spreadsheet)\\n\\n workbook = openpyxl.load_workbook(spreadsheet.tofile(), read_only=True, data_only=True) # Load in read-only mode for performance, since we don't parse comments etc.\\n validate_category(workbook, \\\"atomica:databook\\\")\\n\\n # These sheets are optional - if none of these are provided in the databook\\n # then they will remain empty\\n self.transfers = list()\\n self.interpops = list()\\n\\n for sheet in workbook.worksheets:\\n\\n if sheet.title.startswith(\\\"#ignore\\\"):\\n continue\\n\\n if sheet.title == \\\"Population Definitions\\\":\\n try:\\n self._read_pops(sheet)\\n except Exception as e:\\n message = 'An error was detected on the \\\"Population Definitions\\\" sheet'\\n raise Exception(\\\"%s -> %s\\\" % (message, e)) from e\\n elif sheet.title == \\\"Transfers\\\":\\n try:\\n self._read_transfers(sheet)\\n except Exception as e:\\n message = 'An error was detected on the \\\"Transfers\\\" sheet'\\n raise Exception(\\\"%s -> %s\\\" % (message, e)) from e\\n elif sheet.title == \\\"Interactions\\\":\\n try:\\n self._read_interpops(sheet)\\n except Exception as e:\\n message = 'An error was detected on the \\\"Interactions\\\" sheet'\\n raise Exception(\\\"%s -> %s\\\" % (message, e)) from e\\n elif sheet.title == \\\"Metadata\\\":\\n continue\\n else:\\n self.tdve_pages[sheet.title] = []\\n tables, start_rows = read_tables(sheet)\\n for table, start_row in zip(tables, start_rows):\\n\\n try:\\n tdve = TimeDependentValuesEntry.from_rows(table)\\n except Exception as e:\\n message = 'Error on sheet \\\"%s\\\" while trying to read a TDVE table starting on row %d' % (sheet.title, start_row)\\n raise Exception(\\\"%s -> %s\\\" % (message, e)) from e\\n\\n # If the TDVE is not in the Framework, that's a critical stop error, because the framework needs to at least declare\\n # what kind of variable this is - otherwise, we don't know the allowed units and cannot write the databook back properly\\n try:\\n spec, item_type = framework.get_variable(tdve.name)\\n except NotFoundError:\\n message = 'Error on sheet \\\"%s\\\" while reading TDVE table \\\"%s\\\" (row %d). The variable was not found in the Framework' % (sheet.title, tdve.name, start_row)\\n raise Exception(message)\\n\\n code_name = spec.name\\n tdve.allowed_units = [framework.get_databook_units(code_name)]\\n tdve.pop_type = spec[\\\"population type\\\"]\\n\\n # Migrate the units (20181114)\\n # All TimeSeries instances in databook TDVE tables should have the same units as the allowed units\\n # However, if the user entered something that is wrong, we need to keep it and alert them during validation\\n # Therefore, we can migrate as long as the _old_ units made sense\\n for ts in tdve.ts.values():\\n if ts.units != tdve.allowed_units[0]:\\n if not ts.units or ts.units.strip().lower() == tdve.allowed_units[0].strip().split()[0].strip().lower():\\n ts.units = tdve.allowed_units[0]\\n\\n if not spec[\\\"databook page\\\"]:\\n logger.warning('A TDVE table for \\\"%s\\\" (%s) was read in and will be used, but the Framework did not mark this quantity as appearing in the databook', tdve.name, code_name)\\n tdve.comment = spec[\\\"guidance\\\"]\\n\\n if code_name in self.tdve:\\n raise Exception('A TDVE table for \\\"%s\\\" (%s) appears more than once in the databook. The first table was on sheet \\\"%s\\\" and the first duplicate table is on sheet \\\"%s\\\" starting on row %d' % (tdve.name, code_name, [k for k, v in self.tdve_pages.items() if code_name in v][0], sheet.title, start_row))\\n\\n self.tdve[code_name] = tdve\\n # Store the TDVE on the page it was actually on, rather than the one in the framework. Then, if users move anything around, the change will persist\\n self.tdve_pages[sheet.title].append(code_name)\\n\\n tvals = set()\\n for tdve in self.tdve.values():\\n tvals.update(tdve.tvec)\\n for tdc in self.transfers + self.interpops:\\n tvals.update(tdc.tvec)\\n self.tvec = np.array(sorted(tvals))\\n\\n return self\",\n \"def import_building_from_excel(\\n project, building_name, construction_age, path_to_excel, sheet_names\\n):\\n\\n def warn_constructiontype(element):\\n \\\"\\\"\\\"Generic warning function\\\"\\\"\\\"\\n if element.construction_type is None:\\n warnings.warn(\\n 'In zone \\\"%s\\\" the %s construction \\\"%s\\\" could not be loaded from the TypeBuildingElements.json, '\\n \\\"an error will occur due to missing data for calculation.\\\"\\n \\\"Check for spelling and the correct combination of building age and construction type.\\\"\\n \\\"Here is the list of faulty entries:\\\\n%s\\\"\\n \\\"\\\\nThese entries can easily be found checking the stated index in the produced ZonedInput.xlsx\\\"\\n % (\\n group[\\\"zone\\\"].iloc[0],\\n element.name,\\n group[\\\"OuterWallConstruction\\\"].iloc[0],\\n group,\\n )\\n )\\n\\n bldg = Building(parent=project)\\n bldg.name = building_name\\n bldg.year_of_construction = construction_age\\n bldg.with_ahu = True # HardCodedInput\\n if bldg.with_ahu is True:\\n bldg.central_ahu.heat_recovery = True # HardCodedInput\\n bldg.central_ahu.efficiency_recovery = 0.35 # HardCodedInput\\n bldg.central_ahu.temperature_profile = 25 * [273.15 + 18] # HardCodedInput\\n bldg.central_ahu.min_relative_humidity_profile = 25 * [0] # HardCodedInput\\n bldg.central_ahu.max_relative_humidity_profile = 25 * [1] # HardCodedInput\\n bldg.central_ahu.v_flow_profile = 25 * [1] # HardCodedInput\\n\\n # Parameters that need hard coding in teasers logic classes\\n # 1. \\\"use_set_back\\\" needs hard coding at aixlib.py in the init; defines\\n # if the in the useconditions stated\\n # heating_time with the respective set_back_temp should be applied.\\n # use_set_back = false -> all hours of the day\\n # have same set_temp_heat actual value: use_set_back = Check your current version!\\n # 2. HeaterOn, CoolerOn, hHeat, lCool, etc. can be hard coded in the text\\n # file\\n # \\\"teaser / data / output / modelicatemplate / AixLib /\\n # AixLib_ThermalZoneRecord_TwoElement\\\"\\n # actual changes: Check your current version!\\n\\n # Parameters to be set for each and every zone (#HardCodedInput)\\n # -----------------------------\\n out_wall_tilt = 90\\n window_tilt = 90\\n ground_floor_tilt = 0\\n floor_tilt = 0\\n ceiling_tilt = 0\\n rooftop_tilt = 0\\n ground_floor_orientation = -2\\n floor_orientation = -2\\n rooftop_orientation = -1\\n ceiling_orientation = -1\\n # -----------------------------\\n\\n # load_building_data from excel_to_pandas DataFrame:\\n data = import_data(path_to_excel, sheet_names)\\n\\n # informative print\\n usage_types = get_list_of_present_entries(data[\\\"UsageType\\\"])\\n print(\\\"List of present usage_types in the original Data set: \\\\n%s\\\" % usage_types)\\n\\n # define the zoning methodology/function\\n data = zoning_example(data)\\n\\n # informative print\\n usage_types = get_list_of_present_entries(data[\\\"Zone\\\"])\\n print(\\\"List of zones after the zoning is applied: \\\\n%s\\\" % usage_types)\\n\\n # aggregate all rooms of each zone and for each set general parameter,\\n # boundary conditions\\n # and parameter regarding the building physics\\n zones = data.groupby([\\\"Zone\\\"])\\n for name, zone in zones:\\n\\n # Block: Thermal zone (general parameter)\\n tz = ThermalZone(parent=bldg)\\n tz.name = str(name)\\n tz.area = zone[\\\"NetArea[m²]\\\"].sum()\\n # room vice calculation of volume plus summing those\\n tz.volume = (\\n np.array(zone[\\\"NetArea[m²]\\\"]) * np.array(zone[\\\"HeatedRoomHeight[m]\\\"])\\n ).sum()\\n\\n # Block: Boundary Conditions\\n # load UsageOperationTime, Lighting, RoomClimate and InternalGains\\n # from the \\\"UseCondition.json\\\"\\n tz.use_conditions = UseConditions(parent=tz)\\n tz.use_conditions.load_use_conditions(zone[\\\"Zone\\\"].iloc[0], project.data)\\n\\n # Block: Building Physics\\n # Grouping by orientation and construction type\\n # aggregating and feeding to the teaser logic classes\\n grouped = zone.groupby([\\\"OuterWallOrientation[°]\\\", \\\"OuterWallConstruction\\\"])\\n for name, group in grouped:\\n # looping through a groupby object automatically discards the\\n # groups where one of the attributes is nan\\n # additionally check for strings, since the value must be of type\\n # int or float\\n if not isinstance(group[\\\"OuterWallOrientation[°]\\\"].iloc[0], str):\\n out_wall = OuterWall(parent=tz)\\n out_wall.name = (\\n \\\"outer_wall_\\\"\\n + str(int(group[\\\"OuterWallOrientation[°]\\\"].iloc[0]))\\n + \\\"_\\\"\\n + str(group[\\\"OuterWallConstruction\\\"].iloc[0])\\n )\\n out_wall.area = group[\\\"OuterWallArea[m²]\\\"].sum()\\n out_wall.tilt = out_wall_tilt\\n out_wall.orientation = group[\\\"OuterWallOrientation[°]\\\"].iloc[0]\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n out_wall.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"OuterWallConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(out_wall)\\n else:\\n warnings.warn(\\n 'In zone \\\"%s\\\" the OuterWallOrientation \\\"%s\\\" is '\\n \\\"neither float nor int, \\\"\\n \\\"hence this building element is not added.\\\\nHere is the \\\"\\n \\\"list of faulty entries:\\\\n%s\\\"\\n \\\"\\\\n These entries can easily be found checking the stated \\\"\\n \\\"index in the produced ZonedInput.xlsx\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"OuterWallOrientation[°]\\\"].iloc[0],\\n group,\\n )\\n )\\n\\n grouped = zone.groupby([\\\"WindowOrientation[°]\\\", \\\"WindowConstruction\\\"])\\n for name, group in grouped:\\n # looping through a groupby object automatically discards the\\n # groups where one of the attributes is nan\\n # additionally check for strings, since the value must be of type\\n # int or float\\n if not isinstance(group[\\\"OuterWallOrientation[°]\\\"].iloc[0], str):\\n window = Window(parent=tz)\\n window.name = (\\n \\\"window_\\\"\\n + str(int(group[\\\"WindowOrientation[°]\\\"].iloc[0]))\\n + \\\"_\\\"\\n + str(group[\\\"WindowConstruction\\\"].iloc[0])\\n )\\n window.area = group[\\\"WindowArea[m²]\\\"].sum()\\n window.tilt = window_tilt\\n window.orientation = group[\\\"WindowOrientation[°]\\\"].iloc[0]\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n window.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"WindowConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(window)\\n else:\\n warnings.warn(\\n 'In zone \\\"%s\\\" the window orientation \\\"%s\\\" is neither '\\n \\\"float nor int, \\\"\\n \\\"hence this building element is not added. Here is the \\\"\\n \\\"list of faulty entries:\\\\n%s\\\"\\n \\\"\\\\nThese entries can easily be found checking the stated \\\"\\n \\\"index in the produced ZonedInput.xlsx\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"WindowOrientation[°]\\\"].iloc[0],\\n group,\\n )\\n )\\n\\n grouped = zone.groupby([\\\"IsGroundFloor\\\", \\\"FloorConstruction\\\"])\\n for name, group in grouped:\\n if group[\\\"NetArea[m²]\\\"].sum() != 0: # to avoid devision by 0\\n if group[\\\"IsGroundFloor\\\"].iloc[0] == 1:\\n ground_floor = GroundFloor(parent=tz)\\n ground_floor.name = \\\"ground_floor\\\" + str(\\n group[\\\"FloorConstruction\\\"].iloc[0]\\n )\\n ground_floor.area = group[\\\"NetArea[m²]\\\"].sum()\\n ground_floor.tilt = ground_floor_tilt\\n ground_floor.orientation = ground_floor_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n ground_floor.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"FloorConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(ground_floor)\\n elif group[\\\"IsGroundFloor\\\"].iloc[0] == 0:\\n floor = Floor(parent=tz)\\n floor.name = \\\"floor\\\" + str(group[\\\"FloorConstruction\\\"].iloc[0])\\n floor.area = group[\\\"NetArea[m²]\\\"].sum() / 2 # only half of\\n # the floor belongs to this story\\n floor.tilt = floor_tilt\\n floor.orientation = floor_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n floor.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"FloorConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(floor)\\n else:\\n warnings.warn(\\n \\\"Values for IsGroundFloor have to be either 0 or 1, \\\"\\n \\\"for no or yes respectively\\\"\\n )\\n else:\\n warnings.warn(\\n 'zone \\\"%s\\\" with IsGroundFloor \\\"%s\\\" and construction '\\n 'type \\\"%s\\\" '\\n \\\"has no floor nor groundfloor, since the area equals 0.\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"IsGroundFloor\\\"].iloc[0],\\n group[\\\"FloorConstruction\\\"].iloc[0],\\n )\\n )\\n\\n grouped = zone.groupby([\\\"IsRooftop\\\", \\\"CeilingConstruction\\\"])\\n for name, group in grouped:\\n if group[\\\"NetArea[m²]\\\"].sum() != 0: # to avoid devision by 0\\n if group[\\\"IsRooftop\\\"].iloc[0] == 1:\\n rooftop = Rooftop(parent=tz)\\n rooftop.name = \\\"rooftop\\\" + str(group[\\\"CeilingConstruction\\\"].iloc[0])\\n rooftop.area = group[\\n \\\"NetArea[m²]\\\"\\n ].sum() # sum up area of respective\\n # rooftop parts\\n rooftop.tilt = rooftop_tilt\\n rooftop.orientation = rooftop_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n rooftop.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"CeilingConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(rooftop)\\n elif group[\\\"IsRooftop\\\"].iloc[0] == 0:\\n ceiling = Ceiling(parent=tz)\\n ceiling.name = \\\"ceiling\\\" + str(group[\\\"CeilingConstruction\\\"].iloc[0])\\n ceiling.area = group[\\\"NetArea[m²]\\\"].sum() / 2 # only half\\n # of the ceiling belongs to a story,\\n # the other half to the above\\n ceiling.tilt = ceiling_tilt\\n ceiling.orientation = ceiling_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n ceiling.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"CeilingConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(ceiling)\\n else:\\n warnings.warn(\\n \\\"Values for IsRooftop have to be either 0 or 1, \\\"\\n \\\"for no or yes respectively\\\"\\n )\\n else:\\n warnings.warn(\\n 'zone \\\"%s\\\" with IsRooftop \\\"%s\\\" and construction type '\\n '\\\"%s\\\" '\\n \\\"has no ceiling nor rooftop, since the area equals 0.\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"IsRooftop\\\"].iloc[0],\\n group[\\\"CeilingConstruction\\\"].iloc[0],\\n )\\n )\\n\\n grouped = zone.groupby([\\\"InnerWallConstruction\\\"])\\n for name, group in grouped:\\n if group[\\\"InnerWallArea[m²]\\\"].sum() != 0: # to avoid devision by 0\\n in_wall = InnerWall(parent=tz)\\n in_wall.name = \\\"inner_wall\\\" + str(\\n group[\\\"InnerWallConstruction\\\"].iloc[0]\\n )\\n in_wall.area = group[\\\"InnerWallArea[m²]\\\"].sum() / 2 # only\\n # half of the wall belongs to each room,\\n # the other half to the adjacent\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n in_wall.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"InnerWallConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(in_wall)\\n else:\\n warnings.warn(\\n 'zone \\\"%s\\\" with inner wall construction \\\"%s\\\" has no '\\n \\\"inner walls, since area = 0.\\\"\\n % (group[\\\"Zone\\\"].iloc[0], group[\\\"InnerWallConstructio\\\" \\\"n\\\"].iloc[0])\\n )\\n\\n # Block: AHU and infiltration #Attention hard coding\\n # set the supply volume flow of the AHU per zone\\n ahu_dict = {\\n \\\"Bedroom\\\": [15.778, 15.778],\\n \\\"Corridorsinthegeneralcarearea\\\": [5.2941, 5.2941],\\n \\\"Examinationortreatmentroom\\\": [15.743, 15.743],\\n \\\"MeetingConferenceseminar\\\": [16.036, 16.036],\\n \\\"Stocktechnicalequipmentarchives\\\": [20.484, 20.484],\\n \\\"WCandsanitaryroomsinnonresidentialbuildings\\\": [27.692, 27.692],\\n }\\n _i = 0\\n for key in ahu_dict:\\n if tz.name == key:\\n tz.use_conditions.min_ahu = ahu_dict[key][0]\\n tz.use_conditions.max_ahu = ahu_dict[key][1]\\n _i = 1\\n if _i == 0:\\n warnings.warn(\\n \\\"The zone %s could not be found in your ahu_dict. Hence, \\\"\\n \\\"no AHU flow is defined. The default value is \\\"\\n \\\"0 (min_ahu = 0; max_ahu=0\\\" % tz.name\\n )\\n\\n return project, data\",\n \"def load_grid(self, elem_file, elec_file):\\n self.load_elem_file(elem_file)\\n self.load_elec_file(elec_file)\",\n \"def get_cell(self, i, j):\\n return self._env[i][j]\",\n \"def get_new_cell(path: tuple(str, ...)) -> dict[str, Any]:\\n return {\\n \\\"path\\\": path,\\n \\\"type\\\": \\\"cell\\\",\\n # \\\"celltype\\\": \\\"structured\\\", # or \\\"text\\\" for help cells\\n \\\"datatype\\\": \\\"mixed\\\",\\n \\\"hash_pattern\\\": None,\\n \\\"UNTRANSLATED\\\": True,\\n }\",\n \"def include_metafile(filename):\\n dislin.incfil(filename)\",\n \"def cython(self, line, cell):\\n from sage.misc.cython_c import cython_compile\\n return cython_compile(cell)\",\n \"def __init__ (self, prototype_filename = None, originX = None, originY = None, cell_Width = None,\\n cell_Height = None, ncols = None, nrows = None):\\n self.prototype_filename = prototype_filename\\n if self.prototype_filename is None:\\n self.originX = originX\\n self.originY = originY\\n self.cell_Width = cell_Width\\n self.cell_Height = cell_Height\\n self.ncols = ncols\\n self.nrows = nrows\\n read_existing_raster = False\\n else: \\n read_existing_raster = True\\n \\n if read_existing_raster:\\n try:\\n self.ras = self.read_raster (self.prototype_filename) # read the raster\\n raster = gdal.Open (self.prototype_filename)\\n geotransform = raster.GetGeoTransform()\\n self.originX = geotransform[0]\\n self.originY = geotransform[3]\\n self.cell_Width = geotransform[1]\\n self.cell_Height = geotransform[5]\\n self.ncols = self.ras.shape[1] # set nrows and cols as local variables for convenience\\n self.nrows = self.ras.shape[0]\\n except:\\n print ('ERROR: raster read error')\\n else:\\n try:\\n self.ras = np.zeros ((self.nrows, self.ncols)) * np.nan\\n except:\\n print ('ERROR: raster creation error')\\n \\n # calculate the indices\\n self.x_index = np.zeros (self.ncols) * np.nan\\n for i in range(0, self.ncols):\\n self.x_index[i] = (i * self.cell_Width) + self.originX + (self.cell_Width / 2.0)\\n\\n self.y_index = np.zeros (self.nrows) * np.nan\\n for j in range(0, self.nrows):\\n # reverse index for rows, so lookups can be more natural\\n ind = self.nrows - j - 1\\n self.y_index[ind] = (j * self.cell_Height) + self.originY + (self.cell_Height / 2.0)\\n\\n return\",\n \"def add(self, cell, overwrite_duplicate=False):\\n if isinstance(cell, Cell):\\n if (not overwrite_duplicate and cell.name in self.cell_dict and\\n self.cell_dict[cell.name] is not cell):\\n raise ValueError(\\\"[GDSPY] cell named {0} already present in \\\"\\n \\\"library.\\\".format(cell.name))\\n self.cell_dict[cell.name] = cell\\n else:\\n for c in cell:\\n if (not overwrite_duplicate and c.name in self.cell_dict and\\n self.cell_dict[c.name] is not c):\\n raise ValueError(\\\"[GDSPY] cell named {0} already present \\\"\\n \\\"in library.\\\".format(c.name))\\n self.cell_dict[c.name] = c\\n return self\",\n \"def add_cell_before(nbcells):\\n insert_before = None\\n for idx, c in enumerate(nbcells):\\n if c['cell_type'] != 'code':\\n continue\\n if ('import matplotlib' in c['source'] or\\n 'from matplotlib' in c['source']):\\n insert_before = idx + 1\\n if style_cell['source'] in c['source']:\\n insert_before = None\\n\\n return insert_before\",\n \"def cell_from_xy(self,x,y):\\n return self.cell_array.item((x,y))\",\n \"def to_gds(self, outfile, multiplier):\\n if isinstance(self.ref_cell, Cell):\\n name = self.ref_cell.name\\n else:\\n name = self.ref_cell\\n if len(name) % 2 != 0:\\n name = name + \\\"\\\\0\\\"\\n outfile.write(struct.pack(\\\">4H\\\", 4, 0x0B00, 4 + len(name), 0x1206))\\n outfile.write(name.encode(\\\"ascii\\\"))\\n x2 = self.origin[0] + self.columns * self.spacing[0]\\n y2 = self.origin[1]\\n x3 = self.origin[0]\\n y3 = self.origin[1] + self.rows * self.spacing[1]\\n if (\\n (self.rotation is not None)\\n or (self.magnification is not None)\\n or self.x_reflection\\n ):\\n word = 0\\n values = b\\\"\\\"\\n if self.x_reflection:\\n word += 0x8000\\n y3 = 2 * self.origin[1] - y3\\n if not (self.magnification is None):\\n # This flag indicates that the magnification is absolute, not\\n # relative (not supported).\\n # word += 0x0004\\n values += struct.pack(\\\">2H\\\", 12, 0x1B05) + _eight_byte_real(\\n self.magnification\\n )\\n if not (self.rotation is None):\\n # This flag indicates that the rotation is absolute, not\\n # relative (not supported).\\n # word += 0x0002\\n sa = numpy.sin(self.rotation * numpy.pi / 180.0)\\n ca = numpy.cos(self.rotation * numpy.pi / 180.0)\\n tmp = (\\n (x2 - self.origin[0]) * ca\\n - (y2 - self.origin[1]) * sa\\n + self.origin[0]\\n )\\n y2 = (\\n (x2 - self.origin[0]) * sa\\n + (y2 - self.origin[1]) * ca\\n + self.origin[1]\\n )\\n x2 = tmp\\n tmp = (\\n (x3 - self.origin[0]) * ca\\n - (y3 - self.origin[1]) * sa\\n + self.origin[0]\\n )\\n y3 = (\\n (x3 - self.origin[0]) * sa\\n + (y3 - self.origin[1]) * ca\\n + self.origin[1]\\n )\\n x3 = tmp\\n values += struct.pack(\\\">2H\\\", 12, 0x1C05) + _eight_byte_real(\\n self.rotation\\n )\\n outfile.write(struct.pack(\\\">3H\\\", 6, 0x1A01, word))\\n outfile.write(values)\\n outfile.write(\\n struct.pack(\\n \\\">2H2h2H6l\\\",\\n 8,\\n 0x1302,\\n self.columns,\\n self.rows,\\n 28,\\n 0x1003,\\n int(round(self.origin[0] * multiplier)),\\n int(round(self.origin[1] * multiplier)),\\n int(round(x2 * multiplier)),\\n int(round(y2 * multiplier)),\\n int(round(x3 * multiplier)),\\n int(round(y3 * multiplier)),\\n )\\n )\\n if self.properties is not None and len(self.properties) > 0:\\n size = 0\\n for attr, value in self.properties.items():\\n if len(value) % 2 != 0:\\n value = value + \\\"\\\\0\\\"\\n outfile.write(\\n struct.pack(\\\">5H\\\", 6, 0x2B02, attr, 4 + len(value), 0x2C06)\\n )\\n outfile.write(value.encode(\\\"ascii\\\"))\\n size += len(value) + 2\\n if size > 128:\\n warnings.warn(\\n \\\"[GDSPY] Properties with size larger than 128 bytes are not \\\"\\n \\\"officially supported by the GDSII specification. This file \\\"\\n \\\"might not be compatible with all readers.\\\",\\n stacklevel=4,\\n )\\n outfile.write(struct.pack(\\\">2H\\\", 4, 0x1100))\",\n \"def gdal_read_geotiff_file(sFilename_in):\\n \\n if os.path.exists(sFilename_in):\\n pass\\n else:\\n print('The file does not exist!')\\n return\\n\\n sDriverName='GTiff'\\n pDriver = gdal.GetDriverByName(sDriverName) \\n\\n if pDriver is None:\\n print (\\\"%s pDriver not available.\\\\n\\\" % sDriverName)\\n else:\\n print (\\\"%s pDriver IS available.\\\\n\\\" % sDriverName) \\n\\n pDataset = gdal.Open(sFilename_in, gdal.GA_ReadOnly)\\n\\n if pDataset is None:\\n print(\\\"Couldn't open this file: \\\" + sFilename_in)\\n sys.exit(\\\"Try again!\\\")\\n else: \\n pProjection = pDataset.GetProjection()\\n\\n pDataset.GetMetadata()\\n \\n ncolumn = pDataset.RasterXSize\\n nrow = pDataset.RasterYSize\\n nband = pDataset.RasterCount\\n\\n pGeotransform = pDataset.GetGeoTransform()\\n dOriginX = pGeotransform[0]\\n dOriginY = pGeotransform[3]\\n dPixelWidth = pGeotransform[1]\\n pPixelHeight = pGeotransform[5]\\n\\n pBand = pDataset.GetRasterBand(1)\\n\\n # Data type of the values\\n gdal.GetDataTypeName(pBand.DataType)\\n # Compute statistics if needed\\n if pBand.GetMinimum() is None or pBand.GetMaximum() is None:\\n pBand.ComputeStatistics(0)\\n\\n dMissing_value = pBand.GetNoDataValue()\\n \\n aData_out = pBand.ReadAsArray(0, 0, ncolumn, nrow)\\n \\n #we will use one of them to keep the consistency\\n pSpatial_reference = osr.SpatialReference(wkt=pProjection)\\n \\n\\n pDataset = None\\n pBand = None \\n pBand = None\\n\\n return aData_out, dPixelWidth, dOriginX, dOriginY, nrow, ncolumn, dMissing_value, pGeotransform, pProjection, pSpatial_reference\",\n \"def get_g(file_name):\\n \\n r,g = np.loadtxt(file_name, dtype = 'float', unpack = 'true')\\n \\n return r,g\",\n \"def load_one_molecule(self, fname, mol=None):\\n outtype = 'float32'\\n fh5 = h5py.File(fname, 'r')\\n\\n if mol is None:\\n mol = list(fh5.keys())[0]\\n\\n # get the mol\\n mol_data = fh5.get(mol)\\n\\n # xue:\\n if 'mapped_features' not in mol_data.keys():\\n logger.error(f\\\"xue: Error: mol: {mol} in {fname} does not have mapped_features \\\")\\n fh5.close()\\n sys.exit()\\n\\n # get the features\\n feature = []\\n for feat_type, feat_names in self.select_feature.items():\\n\\n # see if the feature exists\\n if 'mapped_features/' + feat_type in mol_data.keys():\\n feat_dict = mol_data.get(\\n 'mapped_features/' + feat_type)\\n else:\\n logger.error(\\n f'Feature type {feat_type} not found in file {fname} '\\n f'for molecule {mol}.\\\\n'\\n f'Possible feature types are:\\\\n\\\\t' +\\n '\\\\n\\\\t'.join(\\n list(mol_data['mapped_features'].keys()))\\n )\\n raise ValueError(feat_type, ' not supported')\\n\\n # loop through all the desired feat names\\n for name in feat_names:\\n\\n # extract the group\\n try:\\n data = feat_dict[name]\\n except KeyError:\\n logger.error(\\n f'Feature {name} not found in file {fname} for mol '\\n f'{mol} and feature type {feat_type}.\\\\n'\\n f'Possible feature are:\\\\n\\\\t' +\\n '\\\\n\\\\t'.join(list(\\n mol_data['mapped_features/' +\\n feat_type].keys()\\n ))\\n )\\n\\n # check its sparse attribute\\n # if true get a FLAN\\n # if flase direct import\\n if data.attrs['sparse']:\\n mat = sparse.FLANgrid(sparse=True,\\n index=data['index'][:],\\n value=data['value'][:],\\n shape=self._grid_shape).to_dense()\\n else:\\n mat = data['value'][:]\\n\\n # append to the list of features\\n feature.append(mat)\\n\\n # get the target value\\n try:\\n target = mol_data.get('targets/' + self.select_target)[()]\\n except Exception:\\n target = None\\n logger.warning(f'No target value for: {fname} - not required for the test set')\\n\\n # close\\n fh5.close()\\n\\n # make sure all the feature have exact same type\\n # if they don't collate_fn in the creation of the minibatch will fail.\\n # Note returning torch.FloatTensor makes each epoch twice longer ...\\n return (np.array(feature).astype(outtype),\\n np.array([target]).astype(outtype))\",\n \"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 storm_analysis.sa_library.cs_decon_utilities_c\\n import storm_analysis.sa_library.dao_fit_c\\n import storm_analysis.sa_library.grid_c\\n import storm_analysis.sa_library.ia_utilities_c\\n import storm_analysis.sa_library.matched_filter_c\\n\\n import storm_analysis.sa_utilities.fitz_c\\n\\n import storm_analysis.simulator.pf_math_c\\n import storm_analysis.simulator.draw_gaussians_c\\n \\n import storm_analysis.spliner.cubic_spline_c\\n import storm_analysis.spliner.cubic_fit_c\",\n \"def locateSigCells(run,ion,codeLoc,testing=0):\\n\\n singleCount = 0\\n\\n # Read in the galaxy's box\\n boxfile = '{0:s}_GZa{1:s}.{2:s}.h5'.format(run.galID,run.expn,ion.name)\\n box = pd.read_hdf(boxfile, 'data')\\n if testing==1:\\n print('Box read in')\\n\\n # Read in the LOS info from lines.info\\n los_info = np.loadtxt('lines.info',skiprows=2)\\n\\n # Determine which transition to use\\n # Only need on, use the transition with the weaker oscillator strength since\\n # this will retain mroe cells than the other transitions\\n waves = fi.transition_name(ion.name,testing)\\n\\n # Open the output file\\n outfile = '{0:s}.{1:s}.{2:s}.i{3:d}.abs_cells.h5'.format(run.galID,\\n run.expn,ion.name,int(run.incline))\\n header = ['wave','LOS','D','cellID','redshift','logN','dobbler_b',\\n 'x', 'y', 'z', 'vx', 'vy', 'vz',\\n 'r', 'nH', 'temperature', 'cell_size', 'SNII', 'SNIa', \\n 'alpha_Zmet', 'ion_density', 'fullLogNstart', 'fullLogNend']\\n\\n # Open the summary file\\n sumfile = '{0:s}_a{1:s}_{2:s}_i{3:d}_absCellsSummary.h5'.format(run.galID,\\n run.expn,ion.name,int(run.incline))\\n sumheader = ['los', 'impact', 'phi', 'wave','startNumCells', 'startEW', 'startlogN', \\n 'endNumCells', 'endEW', 'endlogN']\\n summary = pd.DataFrame(columns=sumheader)\\n\\n # Write a header to the output file\\n numcols = len(header)\\n\\n # Create a blank row of zeros to build the array with\\n d = pd.DataFrame(columns=header)\\n\\n # Make a version of Mockspec.runpars that has zero SNR\\n # Needed for sigcells\\n lf.quiet_mockspec()\\n\\n # Get a list of LOS that have a sysabs file associated with it\\n #sysabs_losnum = glob.glob('*los*sysabs')\\n #sysabs_losnum.sort()\\n \\n if testing==1:\\n print('Sysabs files aggregated')\\n print('Number of sysabs files: ', len(sysabs_losnum))\\n\\n flog = open('sig_cells.log', 'w')\\n falselog = open('falseDetections.log','w')\\n falselog.write('los\\\\tEWsysabs\\\\tv-\\\\tv+\\\\tInitNumCells\\\\n')\\n\\n # Loop over lines of sight\\n sysabsFilename = '{0:s}.{1:s}.los{2:s}.sysabs'\\n for i in range(0,run.nlos):\\n\\n #losnum = sysabs_losnum[i].split('.')[2].split('los')[1]\\n num = i+1\\n losnum = '{0:04d}'.format(num)\\n\\n linesfile = '{0:s}.{1:s}.los{2:s}.lines'.format(run.galID,ion.name,losnum)\\n\\n # See if sysabs file exists for this losnum\\n sysabsfname = sysabsFilename.format(run.galID,\\n ion.name,losnum)\\n try:\\n f = open(sysabsfname,'r')\\n except IOError:\\n continue\\n\\n # Get the column density of the LOS from the lines file\\n logNinitial = lf.linesLogN(linesfile)\\n\\n # Make sure the .lines file has cells in it\\n numCells = 0\\n with open(linesfile) as f:\\n for line in f:\\n numCells += 1\\n\\n # There is always the galaxy redshift\\n if numCells==1:\\n # If there are no cells, continue to the next LOS\\n continue \\n\\n # Get the impact paramter of this LOS\\n imp = los_info[num-1,1]\\n phi = los_info[num-1,2]\\n \\n # Loop over the different transitions\\n for wave in waves:\\n losSummary = pd.Series(index=sumheader)\\n losSummary['wave'] = wave\\n losSummary['los'] = num\\n losSummary['startNumCells'] = numCells\\n losSummary['impact'] = imp\\n losSummary['phi'] = phi\\n losSummary['startlogN'] = lf.linesLogN(linesfile)\\n\\n # Copy the original lines file\\n command = 'cp {0:s} {0:s}.tmp'.format(linesfile)\\n sp.call(command, shell=True)\\n\\n # Perform the velocity cut\\n lf.velcut(linesfile, testing=testing)\\n\\n # Find the significant cells\\n endCut,startEW,endEW = sg.sigcells(linesfile,run.sigcellsCut,codeLoc,\\n flog,falselog,wave,testing=testing)\\n\\n # Get the properties of the cells\\n # Open the lines.final file\\n finalLinesFile = linesfile.replace('.lines',\\n '.{0:s}.lines.final'.format(wave))\\n logNfinal = lf.linesLogN(finalLinesFile)\\n losSummary['endlogN'] = logNfinal\\n losSummary['startEW'] = startEW\\n losSummary['endEW'] = endEW\\n\\n final_file = open(finalLinesFile)\\n final_file.readline()\\n\\n endNumCells = 0\\n \\n # Loop over the significant cells\\n for line in final_file:\\n endNumCells += 1\\n l = line.split()\\n redshift = float(l[0])\\n column = float(l[1])\\n doppler = float(l[2])\\n cellID = int(float(l[3]))\\n \\n # Get the cell's properties from the boxfile\\n index = cellID-1\\n x = box['x'].iloc[index]\\n y = box['y'].iloc[index]\\n z = box['z'].iloc[index]\\n \\n # Calculate the galactocentric distance\\n r = np.sqrt(x*x + y*y + z*z)\\n \\n cell = pd.Series(index=header)\\n cell['wave'] = wave\\n cell['LOS'] = num\\n cell['D'] = imp\\n cell['cellID'] = cellID\\n cell['redshift'] = redshift\\n cell['logN'] = column \\n cell['dobbler_b'] = doppler\\n cell['x'] = x\\n cell['y'] = y \\n cell['z'] = z \\n cell['vx'] = box['vx'].iloc[index]\\n cell['vy'] = box['vy'].iloc[index]\\n cell['vz'] = box['vz'].iloc[index]\\n cell['r'] = r\\n cell['nH'] = np.log10(box['nH'].iloc[index])\\n cell['temperature'] = np.log10(box['temperature'].iloc[index])\\n cell['cell_size'] = box['cell_size'].iloc[index]\\n cell['SNII'] = np.log10(box['SNII'].iloc[index])\\n cell['SNIa'] = np.log10(box['SNIa'].iloc[index])\\n cell['alpha_Zmet'] = box['alpha_Zmet'].iloc[index]\\n cell['ion_density'] = np.log10(box['nIon'].iloc[index])\\n cell['fIon'] = np.log10(box['fIon'].iloc[index])\\n cell['fullLogNstart'] = logNinitial\\n cell['fullLogNend'] = logNfinal\\n \\n # Append to the main array\\n d = d.append(cell,ignore_index=True)\\n \\n losSummary['endNumCells'] = endNumCells\\n summary = summary.append(losSummary,ignore_index=True)\\n\\n # Rename the original .lines file back to its full name\\n command = 'cp {0:s}.tmp {0:s}'.format(linesfile)\\n sp.call(command, shell=True)\\n \\n # Write the outfile\\n d.to_hdf(outfile,'data',mode='w')\\n summary.to_hdf(sumfile,'data',mode='w')\\n\\n print('For {0:s}, {1:d} LOS are dominated by one cell'.format(ion.name,\\n singleCount))\\n\\n flog.close()\\n falselog.close()\",\n \"def read_data(self):\\n try:\\n return pd.read_excel(self.address)\\n except FileNotFoundError:\\n raise FileNotFoundError('Make sure the linker selex file is in the project folder')\",\n \"def ImportControlPz3D(piez_path,sheet_name,geol_layer,layer_num,geol_col,grid,nlay,np_col=\\\"NP\\\",x_col=\\\"x\\\",y_col=\\\"y\\\"):\\n \\n data = pd.read_excel(piez_path,sheet_name=sheet_name)\\n\\n geol_layer = geol_layer\\n layer_num = layer_num\\n\\n Control_pz = np.zeros([nlay,grid.nrow,grid.ncol]) #ini list\\n\\n for ilay in range(len(geol_layer)): # go through each different lithology\\n lstIDpz=[]\\n Pz=[]\\n DB = data[data[geol_col]==geol_layer[ilay]]\\n DB.reset_index(inplace=True)\\n for o in np.arange(DB.shape[0]): # loop to iterate through the data and returns the intersected cellids\\n xc = DB[x_col][o]\\n yc = DB[y_col][o] \\n cellid = grid.intersect(xc,yc)\\n\\n if not np.isnan(DB[np_col][o]):\\n lstIDpz.append(cellid)\\n Pz.append(DB[np_col][o])\\n\\n df = pd.DataFrame()\\n df[\\\"cellid\\\"]=lstIDpz\\n df[\\\"Pz\\\"] = Pz\\n df = df.groupby([\\\"cellid\\\"]).mean().reset_index() # group pz and apply mean on the same cell\\n\\n for i in df.index:\\n j,k = df.loc[i,\\\"cellid\\\"]\\n Control_pz[layer_num[ilay],j,k] = df.loc[i,\\\"Pz\\\"]\\n\\n return Control_pz\",\n \"def populate_contents(self):\\n\\n guitile = self.guitile\\n tile = guitile.tile\\n scene = guitile.parent\\n world = scene.world\\n data = scene.data\\n data_table = scene.mainwindow.data_table\\n\\n # Actually populate the grid. TODO: Taking some of this info directly\\n # from the DataTable, which is a bit unseemly. Should push that\\n # stuff into a proper data class.\\n\\n self.add_text_row('Region', '({:d}, {:d})'.format(guitile.region.rx, guitile.region.ry))\\n self.add_text_row('Coordinates', '({:d}, {:d})'.format(guitile.x, guitile.y))\\n self.add_lookup_text_row('Foreground Material', tile.foreground_material, data.materials)\\n self.add_lookup_text_row('Foreground Material Mod', tile.foreground_mod, data.matmods)\\n self.add_lookup_text_row('Background Material', tile.background_material, data.materials)\\n self.add_lookup_text_row('Background Material Mod', tile.background_mod, data.matmods)\\n\\n # Liquids\\n if tile.liquid_level > 0:\\n extra_liquid = ' at {:d}%'.format(round(tile.liquid_level*100))\\n else:\\n extra_liquid = ''\\n self.add_lookup_text_row('Liquid', tile.liquid, data.liquids,\\n extra=extra_liquid, nothing=0)\\n\\n # Plants\\n if len(guitile.plants) > 1:\\n show_index = ' {}'.format(idx+1)\\n else:\\n show_index = ''\\n for idx, (plant_desc, parts) in enumerate(guitile.plants):\\n partlist = set()\\n for (part, _) in parts:\\n partlist.add(part.pathname)\\n if len(parts) == 1:\\n plural = ''\\n else:\\n plural = 's'\\n self.add_text_row(\\n 'Plant{}'.format(show_index),\\n '{} ({} part{})'.format(plant_desc, len(parts), plural),\\n )\\n if len(partlist) > 0:\\n self.add_list_data(sorted(partlist))\\n self.cur_row += 1\\n\\n # Objects\\n if len(guitile.objects) > 1:\\n show_index = ' {}'.format(idx+1)\\n else:\\n show_index = ''\\n for idx, (obj_data, obj_name, obj_orientation, _, entity) in enumerate(guitile.objects):\\n object_label = 'Object{}'.format(show_index)\\n self.add_text_row(\\n object_label,\\n '<tt>{}</tt> ({})'.format(obj_name, StarboundData.strip_colors(obj_data.info['shortdescription'])),\\n )\\n self.add_text_data('<tt>{}</tt>'.format(obj_data.full_path))\\n self.cur_row += 1\\n orient = obj_data.get_image_path(obj_orientation)\\n if orient:\\n self.add_text_data('<tt>{}</tt>'.format(orient))\\n self.cur_row += 1\\n if 'items' in entity:\\n itemlist = []\\n for item in entity['items']:\\n if item and 'content' in item:\\n content = item['content']\\n if 'parameters' in content and 'shortdescription' in content['parameters']:\\n if content['name'] in data.items:\\n suffix = ' ({}: {})'.format(data.items[content['name']], content['parameters']['shortdescription'])\\n else:\\n suffix = ' ({})'.format(content['parameters']['shortdescription'])\\n elif content['name'] in data.items:\\n suffix = ' ({})'.format(data.items[content['name']])\\n else:\\n suffix = ''\\n itemlist.append((\\n content['name'],\\n content['count'],\\n '{}x {}{}'.format(content['count'], content['name'], suffix),\\n ))\\n if len(itemlist) > 0:\\n self.add_list_data_row(\\n '{} Contents'.format(object_label),\\n [i[2] for i in sorted(itemlist)],\\n )\",\n \"def test_get_cell(workbook):\\n assert workbook.get_cell(3,1) == '507906000030242007'\",\n \"def read_library(self):\\n # Create a new file set and populate it with all the library files.\\n self.files = files.Files()\\n try:\\n openfile = self.files.open_file\\n # Initialise miscellaneous cell info\\n with openfile('INFO') as file:\\n info = file.readlines()\\n for detector in self.detectors.itervalues():\\n detector.set_info(info)\\n # Open calibration information\\n with openfile('CURVE_LARGE') as l, openfile('CURVE_SMALL') as s:\\n cal = calibration.Table(l, s)\\n for detector in self.detectors.itervalues():\\n detector.set_calibration(cal)\\n except IOError as err:\\n tkMessageBox.askyesno('I/O error', str(err))\\n self.image_window.canvas.focus_set()\",\n \"def load_xl2db(xlfilepath, sheetname, header_cols, insfunc, start_row=0):\\n def is_header(row):\\n hText = ('!!'.join(header_cols)).lower()\\n rText = ('!!'.join([str(r) for r in row[:len(header_cols)]])).lower()\\n return hText == rText\\n \\n #load sheet & file header\\n sheet = XlSheet(xlfilepath, sheetname)\\n row = sheet.getrow()\\n while not is_header(row):\\n row = sheet.getrow()\\n \\n # now perform data load\\n for row in sheet.getrows(start_row=(start_row or 0)):\\n insfunc(norm_row(row))\",\n \"def load_ipython_extension(ipython):\\n\\n for module in _MAGICS:\\n ipython.register_magic_function(\\n getattr(module, 'magic'),\\n magic_kind='line_cell',\\n magic_name=getattr(module, 'MAGIC_NAME'))\",\n \"def loadstack(hdrfile, master):\\r\\n \\r\\n with open(hdrfile, 'r') as hdr:\\r\\n ln = hdr.readline()\\r\\n \\r\\n while 'ScanDefinition' not in ln:\\r\\n ln = hdr.readline()\\r\\n scantype = ln.split(';')[1][9:-1]\\r\\n \\r\\n while 'Axis = { Name = \\\\\\\"Energy\\\\\\\"' not in ln:\\r\\n ln = hdr.readline()\\r\\n \\r\\n ln = hdr.readline()\\r\\n energies = ln[:ln.index(')')]\\r\\n energies = energies.split(', ')\\r\\n energies = [float(en) for en in energies[1:]]\\r\\n \\r\\n \\r\\n if \\\"Line Scan\\\" in scantype:\\r\\n while 'Axis = { Name = \\\\\\\"Sample\\\\\\\"' not in ln:\\r\\n ln = hdr.readline()\\r\\n \\r\\n ln = ln.split()\\r\\n dims = [energies[-1] - energies[0], float(ln[ln.index('Max')+2][:-1]) - float(ln[ln.index('Min')+2][:-1]), 1.0, 1.0 ]\\r\\n ln = hdr.readline()\\r\\n ln = ln.split()\\r\\n dims[2] = int(ln[ln.index('Points')+2][1:-1])\\r\\n dims[3] = dims[1]/float(dims[2])\\r\\n \\r\\n else:\\r\\n while 'XRange = ' not in ln:\\r\\n ln = hdr.readline()\\r\\n \\r\\n ln = ln.split()\\r\\n dims = [ln[ln.index(s) + 2] for s in ['XRange', 'YRange', 'XStep', 'YStep']]\\r\\n dims = [float(d[:-1]) for d in dims]\\r\\n \\r\\n workdir = path.dirname(hdrfile)\\r\\n prefix = path.basename(hdrfile)[:-4]\\r\\n ximlist = glob(path.join(workdir, prefix) + '*.xim')\\r\\n ximlist.sort()\\r\\n ximlist = [path.abspath(f) for f in ximlist]\\r\\n raw = []\\r\\n for k in range(len(ximlist)):\\r\\n master.stackdisp.set('Loading image ' + str(k+1) + '/' + str(len(ximlist)))\\r\\n master.master.update_idletasks()\\r\\n raw.append(np.loadtxt(ximlist[k])[::-1])\\r\\n \\r\\n return [energies, dims, raw, ximlist, scantype]\",\n \"def mtz_get_cell(mtz_filename):\\n\\n xdata = mtz_get_xdata(mtz_filename)\\n\\n return xdata[0:6]\",\n \"def import_agilent_cannabinoids(file_name):\\n return import_agilent_gc_residual_solvents(file_name)\",\n \"def load_youd_bartlett_demo():\\n return read_excel(join(dirname(__file__),'YoudHansenBartlett2002_demo.xls'))\",\n \"def ICRFFile_Instance():\\n return _gmat_py.ICRFFile_Instance()\",\n \"def load(self, filename):\\n LIB.mnt_grid_load.argtypes = [POINTER(c_void_p), c_char_p]\\n fm = filename.encode('utf-8')\\n ier = LIB.mnt_grid_load(self.obj, fm)\\n if ier:\\n error_handler(FILE, 'load', ier)\",\n \"def import_agilent_gc_residual_solvents(file_name):\\n df = pd.read_excel(file_name, sheet_name = None)\\n samples = get_sample_name(df)\\n df_compound = get_compound_df(df)\\n samples['metrics'] = df_compound[['analyte', 'measurement']].to_dict('records')\\n return samples\",\n \"def __init__(\\n self,\\n file_io: Union[str, PurePath, IO],\\n fmt: Union[str, None] = None,\\n muon_symbol: Union[str, int] = \\\"H\\\",\\n ):\\n\\n self._cell_atoms = []\\n self._muon_index = None\\n self._muon_symbol = muon_symbol\\n self._symbols_zero_spin = []\\n\\n self._efg_tensors = None\\n\\n # Load the atomic data from the file\\n # NOTE: Calculator is loaded automatically - can't see a way to\\n # disable but this will cause warnings when reading CASTEP files\\n # without a CASTEP installation - these can be ignored\\n loaded_atoms = ase.io.read(file_io, format=fmt)\\n\\n lengths_and_angles = loaded_atoms.get_cell_lengths_and_angles()\\n self._unit_lengths = lengths_and_angles[:3]\\n self._unit_angles = lengths_and_angles[3:]\\n\\n # ase has a make_supercell method, unfortunately this is not suitable\\n # as need indices to remain same for linking to other files\\n if (self._unit_angles != 90).any():\\n raise ValueError(\\n f\\\"Structure file '{file_io}' has unsupported unit cell angles\\\"\\n )\\n\\n # Load optional data\\n if loaded_atoms.has(\\\"efg\\\"):\\n # Load the efg tensors\\n self._efg_tensors = loaded_atoms.get_array(\\\"efg\\\")\\n\\n self._cell_atoms = [None] * len(loaded_atoms)\\n\\n # Store only needed data for calculations\\n for i, loaded_atom in enumerate(loaded_atoms):\\n\\n # Determine isotope by looking at loaded mass\\n default_mass = ase.data.atomic_masses[\\n ase.data.atomic_numbers[loaded_atom.symbol]\\n ]\\n isotope = _get_isotope(loaded_atom.mass, default_mass)\\n\\n if loaded_atom.symbol == muon_symbol:\\n if self._muon_index is None:\\n self._muon_index = i\\n else:\\n raise ValueError(\\n f\\\"Structure file '{file_io}' has more than one muon \\\"\\n f\\\"with symbol {muon_symbol}\\\"\\n )\\n\\n self._cell_atoms[i] = CellAtom(\\n i + 1, loaded_atom.symbol, isotope, loaded_atom.position\\n )\\n\\n # Keep track of any atoms with zero spin (so can exclude later)\\n if (\\n loaded_atom.symbol not in self._symbols_zero_spin\\n and spin(elem=loaded_atom.symbol, iso=isotope) == 0\\n ):\\n self._symbols_zero_spin.append(loaded_atom.symbol)\\n\\n if self._muon_index is None:\\n raise ValueError(\\n f\\\"Structure file '{file_io}' has no muon with symbol \\\" f\\\"{muon_symbol}\\\"\\n )\",\n \"def __init__(self, cell):\\n self._cell = cell\\n self._residual_fn = gnmt_residual_fn\",\n \"def lib(self) -> Optional[xsLibraries.IsotxsLibrary]:\\n isotxsFileName = nuclearDataIO.getExpectedISOTXSFileName()\\n if self._lib is None and os.path.exists(isotxsFileName):\\n runLog.info(f\\\"Loading microscopic cross section library `{isotxsFileName}`\\\")\\n self._lib = nuclearDataIO.isotxs.readBinary(isotxsFileName)\\n return self._lib\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7146233","0.5359825","0.53328305","0.52091736","0.5137022","0.51339316","0.5118252","0.5001852","0.49921566","0.4971133","0.49391878","0.4921173","0.49046072","0.48940232","0.48588583","0.48488533","0.48184195","0.4751385","0.47495297","0.4736816","0.47112766","0.47019655","0.46877936","0.4683013","0.46646816","0.46633863","0.46613854","0.46469417","0.46201837","0.46176943","0.46119916","0.46072268","0.45959926","0.45772776","0.457601","0.45529604","0.45522836","0.45479876","0.45439124","0.45418355","0.45308182","0.45259094","0.4519688","0.45159233","0.4507299","0.45030057","0.45002353","0.45000845","0.4492622","0.4491475","0.44681835","0.4458784","0.4457288","0.4455157","0.44537398","0.44479394","0.44472054","0.4442395","0.44258565","0.44161218","0.4411359","0.44103447","0.4406477","0.4403087","0.4395631","0.43903843","0.4376035","0.43690455","0.436739","0.4364091","0.43535477","0.43480602","0.4341035","0.43364602","0.43352267","0.43305886","0.43291193","0.43218496","0.43166047","0.4313749","0.43130302","0.4311027","0.4309924","0.43095988","0.4307978","0.43069834","0.4302072","0.43019298","0.43012258","0.42903364","0.4288147","0.42865494","0.4281717","0.4279908","0.4278259","0.42756343","0.42737633","0.42733714","0.4270299","0.42688298"],"string":"[\n \"0.7146233\",\n \"0.5359825\",\n \"0.53328305\",\n \"0.52091736\",\n \"0.5137022\",\n \"0.51339316\",\n \"0.5118252\",\n \"0.5001852\",\n \"0.49921566\",\n \"0.4971133\",\n \"0.49391878\",\n \"0.4921173\",\n \"0.49046072\",\n \"0.48940232\",\n \"0.48588583\",\n \"0.48488533\",\n \"0.48184195\",\n \"0.4751385\",\n \"0.47495297\",\n \"0.4736816\",\n \"0.47112766\",\n \"0.47019655\",\n \"0.46877936\",\n \"0.4683013\",\n \"0.46646816\",\n \"0.46633863\",\n \"0.46613854\",\n \"0.46469417\",\n \"0.46201837\",\n \"0.46176943\",\n \"0.46119916\",\n \"0.46072268\",\n \"0.45959926\",\n \"0.45772776\",\n \"0.457601\",\n \"0.45529604\",\n \"0.45522836\",\n \"0.45479876\",\n \"0.45439124\",\n \"0.45418355\",\n \"0.45308182\",\n \"0.45259094\",\n \"0.4519688\",\n \"0.45159233\",\n \"0.4507299\",\n \"0.45030057\",\n \"0.45002353\",\n \"0.45000845\",\n \"0.4492622\",\n \"0.4491475\",\n \"0.44681835\",\n \"0.4458784\",\n \"0.4457288\",\n \"0.4455157\",\n \"0.44537398\",\n \"0.44479394\",\n \"0.44472054\",\n \"0.4442395\",\n \"0.44258565\",\n \"0.44161218\",\n \"0.4411359\",\n \"0.44103447\",\n \"0.4406477\",\n \"0.4403087\",\n \"0.4395631\",\n \"0.43903843\",\n \"0.4376035\",\n \"0.43690455\",\n \"0.436739\",\n \"0.4364091\",\n \"0.43535477\",\n \"0.43480602\",\n \"0.4341035\",\n \"0.43364602\",\n \"0.43352267\",\n \"0.43305886\",\n \"0.43291193\",\n \"0.43218496\",\n \"0.43166047\",\n \"0.4313749\",\n \"0.43130302\",\n \"0.4311027\",\n \"0.4309924\",\n \"0.43095988\",\n \"0.4307978\",\n \"0.43069834\",\n \"0.4302072\",\n \"0.43019298\",\n \"0.43012258\",\n \"0.42903364\",\n \"0.4288147\",\n \"0.42865494\",\n \"0.4281717\",\n \"0.4279908\",\n \"0.4278259\",\n \"0.42756343\",\n \"0.42737633\",\n \"0.42733714\",\n \"0.4270299\",\n \"0.42688298\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6714337"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":16496,"cells":{"query":{"kind":"string","value":"Write the specified cell to the file."},"document":{"kind":"string","value":"def write_cell(self, cell, timestamp=None):\n cell.to_gds(self._outfile, self._res, timestamp)\n return self"},"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 write_cell(self, cell):\n self._outfile.write(cell.to_gds(self._res))\n return self","def writeCell(hoja, fila, columna, dato, formato=''):\r\n if formato:\r\n hoja.write(fila, columna, dato, formato)\r\n else:\r\n hoja.write(fila, columna, dato)","def write_cell(self, sheet_name, row, column, value, color='black'):\n if isinstance(row, int) and isinstance(column, int):\n try:\n cell_obj = self.wb[sheet_name].cell(row, column)\n cell_obj.font = Font(color=self.RGBDict[color], bold=True)\n cell_obj.value = value\n self.wb.save(self.filename)\n logger.info(\"Excel文件[{}]表单[{}]写入数据[{}]\".format(self.filename, sheet_name, value))\n except Exception as e:\n logger.error(\"Excel文件[{}]表单[{}]写入数据错误\\n错误信息:{}\".format(self.filename, sheet_name, e))\n raise e\n else:\n logger.error(\"Excel文件写入数据错误\\n错误信息:{}\".format('row and column must be type int'))\n raise TypeError('row and column must be type int')","def write(self, fname):\n pass","def setOutCell(outSheet, col, row, value):\n\n def _getOutCell(outSheet, colIndex, rowIndex):\n \"\"\" HACK: Extract the internal xlwt cell representation. \"\"\"\n row = outSheet._Worksheet__rows.get(rowIndex)\n if not row: return None\n\n cell = row._Row__cells.get(colIndex)\n return cell\n\n # HACK to retain cell style.\n previousCell = _getOutCell(outSheet, col, row)\n # END HACK, PART I\n\n outSheet.write(row, col, value)\n\n # HACK, PART II\n if previousCell:\n newCell = _getOutCell(outSheet, col, row)\n if newCell:\n newCell.xf_idx = previousCell.xf_idx\n # END HACK","def write(self, filename):\n pass","def write(self, filename):\n pass","def write_to_file(self, filename: str) -> None:","def cell_file(self, filename, append=False):\n if filename.startswith(\"~\"):\n filename = os.path.expanduser(filename)\n filename = os.path.abspath(filename)\n # Create the path of the file if dirs don't exist:\n path = os.path.dirname(os.path.abspath(filename))\n try:\n os.makedirs(path)\n except OSError as exc: # Python >2.5\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise\n # Create or append to file:\n if not append:\n message = \"Created file '%s'.\" % filename\n if os.path.isfile(self.code):\n message = \"Overwrote file '%s'.\" % filename\n else:\n message = \"Appended on file '%s'.\" % filename\n try:\n if append:\n fp = open(filename, \"a\")\n else:\n fp = open(filename, \"w\")\n fp.write(self.code)\n fp.close()\n self.kernel.Print(message)\n except Exception as e:\n self.kernel.Error(str(e))\n self.evaluate = False","def write_gds(self, outfile, cells=None, timestamp=None):\n if isinstance(outfile, basestring):\n outfile = open(outfile, 'wb')\n close = True\n else:\n close = False\n now = datetime.datetime.today() if timestamp is None else timestamp\n name = self.name if len(self.name) % 2 == 0 else (self.name + '\\0')\n outfile.write(\n struct.pack('>19h', 6, 0x0002, 0x0258, 28, 0x0102, now.year,\n now.month, now.day, now.hour, now.minute, now.second,\n now.year, now.month, now.day, now.hour, now.minute,\n now.second, 4 + len(name), 0x0206) +\n name.encode('ascii') + struct.pack('>2h', 20, 0x0305) +\n _eight_byte_real(self.precision / self.unit) +\n _eight_byte_real(self.precision))\n if cells is None:\n cells = self.cell_dict.values()\n else:\n cells = [self.cell_dict.get(c, c) for c in cells]\n for cell in cells:\n outfile.write(cell.to_gds(self.unit / self.precision))\n outfile.write(struct.pack('>2h', 4, 0x0400))\n if close:\n outfile.close()","def write_to_cell(table, row, col, text):\n\n\ttable.cell(row, col).paragraphs[0].runs[0].text = text","def write_towhee_coord(self, filename):\n with open(filename, 'w') as f:\n df = self.contents[['X', 'Y', 'Z']].copy()\n np.savetxt(f, df.values, fmt=\" %20.15f\"*3)","def write_file(self):\n if self._write_file == None:\n return\n\n try:\n out = file(self._write_file, \"w\")\n except IOError, e:\n print e\n sys.exit(1)\n out.writelines(\"A cases\") \n out.close()","def writetofile(self,direction,value):\r\n output = str(\"{},{} \\n\".format(direction,value))\r\n self.new_file.write(output)","def save_GRID( self , filename ):\n self._fwrite_GRID( filename )","def w(self, value):\n self.oFile.write(value)","def write( self, NewFilename='', Integer=True ):\n try:\n if NewFilename != '':\n self.name=NewFilename\n Output = open( self.name, 'w' )\n Output.write( 'ncols\\t\\t %d\\n' % self.ncols )\n Output.write( 'nrows\\t\\t %d\\n' % self.nrows )\n Output.write( 'xllcorner\\t\\t %f\\n' % self.xllcorner)\n Output.write( 'yllcorner\\t\\t %f\\n' % self.yllcorner)\n Output.write( 'cellsize\\t\\t %f\\n' % self.cellsize)\n if Integer:\n Output.write( 'NODATA_value\\t\\t %d\\n' % int(self.nodata) )\n else:\n Output.write( 'NODATA_value\\t\\t %f\\n' % self.nodata )\n for row in range( self.nrows-1,-1,-1 ):\n record = []\n for col in range( self.ncols ):\n if Integer:\n record.append( str( int( round( self.data[row,col]) ) ) )\n else:\n record.append( str(self.data[row,col]) )\n Output.write( string.join(record, ' ')+'\\n' )\n Output.close()\n except:\n print \"Error writing grid ::\", self.name","def setCell(self, row = None, column = None, value = None, *, cell = None):\n\n\t\t\t\tif (cell is None):\n\t\t\t\t\tcell = self.getCell(row = row, column = column)\n\n\t\t\t\tif (value is None):\n\t\t\t\t\tvalue = \"\"\n\n\t\t\t\t#Write Value\n\t\t\t\tfor _cell in self.ensure_container(cell):\n\t\t\t\t\t_cell.value = f\"{value}\" #Make sure input is a valid ascii","def filewrite(self, filename):\n io.write(self, filename)","def write_file(file_name, table):\r\n \r\n savectr=len(table)\r\n try:\r\n with open (file_name, 'wb') as objFile:\r\n pickle.dump(table,objFile) #pickle my 2D list\r\n print ('{} CD(s) saved into {}.\\n'.format(savectr,file_name))\r\n except PermissionError as e:\r\n print('Not enough rights to create/modify ' + file_name + '.') #if unable pickle data due to permission issues\r\n print ()\r\n print (e, e.__doc__, sep='\\n')\r\n print ()\r\n except IOError as e:\r\n print ('I/O error({0}): {1}'.format(e.errno,e.strerror))#if unable to pickle data due to IO errors such as disk space issues\r\n print ()\r\n print (e, e.__doc__, sep='\\n')\r\n print ()\r\n except pickle.PickleError as e:\r\n print ('Unable to write data into ' + file_name + '.') #if unable to pickle 2D list, exception handling for pickling errors\r\n print ()\r\n print (e, e.__doc__, sep='\\n')\r\n print ()","def write_to_file(self, time):\n if Parameters.instance().use_ages:\n nb_age_groups = len(Parameters.instance().age_proportions)\n else:\n nb_age_groups = 1\n if Parameters.instance().use_ages:\n if self.spatial_output: # Separate output line for each cell\n for cell in self.population.cells:\n for age_i in range(0, nb_age_groups):\n data = {s: 0 for s in list(InfectionStatus)}\n for inf_status in data:\n data_per_inf_status =\\\n cell.compartment_counter.retrieve()[inf_status]\n data[inf_status] += data_per_inf_status[age_i]\n # Age groups are numbered from 1 to the total number\n # of age groups (thus the +1):\n data[\"age_group\"] = age_i+1\n data[\"time\"] = time\n data[\"cell\"] = cell.id\n data[\"location_x\"] = cell.location[0]\n data[\"location_y\"] = cell.location[1]\n self.writer.write(data)\n else: # Summed output across all cells in population\n data = {s: 0 for s in list(InfectionStatus)}\n for cell in self.population.cells:\n for age_i in range(0, nb_age_groups):\n for inf_status in list(InfectionStatus):\n data_per_inf_status =\\\n cell.compartment_counter.retrieve()[inf_status]\n data[inf_status] += data_per_inf_status[age_i]\n data[\"age_group\"] = age_i+1\n data[\"time\"] = time\n self.writer.write(data)\n else: # If age not considered, age_group not written in csv\n if self.spatial_output: # Separate output line for each cell\n for cell in self.population.cells:\n data = {s: 0 for s in list(InfectionStatus)}\n for k in data:\n data[k] += sum(cell.compartment_counter.retrieve()[k])\n data[\"time\"] = time\n data[\"cell\"] = cell.id\n data[\"location_x\"] = cell.location[0]\n data[\"location_y\"] = cell.location[1]\n self.writer.write(data)\n else: # Summed output across all cells in population\n data = {s: 0 for s in list(InfectionStatus)}\n for cell in self.population.cells:\n for k in data:\n # Sum across age compartments\n data[k] += sum(cell.compartment_counter.retrieve()[k])\n data[\"time\"] = time\n self.writer.write(data)","def write_table(table, file_path):\n\n\twith open(file_path, 'w') as file:\n\t\tfile.write(table)","def write_to(self, filename):\n with open(filename, 'w') as f:\n for xx, yy, zz, ww in zip(self.x, self.y, self.field, self.weight):\n f.write(\"%s %s %s %s\\n\" % (xx, yy, zz, ww))\n logger.info(\"Written data into file {0}\".format(filename))","def write_to_file(fib_details: dict):\n pass # TODO: Replace with implementation!","def write_to_sheet(self):\n for i, row in enumerate(self.ws[self.range_name]):\n if isinstance(self.data[i], tuple):\n self.data[i] = list(self.data[i])\n for j, cell in enumerate(row):\n cell.value = self.data[i][j]","def write_CASTEP_cell(CASTEP_cell,filename):\n f=open(seedname+\".cell\",\"r\")\n castep_cell = f.readlines()\n global hashes\n f=StringIO.StringIO()\n f.write(\"%BLOCK LATTICE_CART\\n\")\n for i in xrange(3):\n f.write(\"{0[0]:>20.15f} {0[1]:>20.15f} {0[2]:>20.15f}\\n\".format(\n (CASTEP_cell[\"lattvec\"][:,i]*10).tolist()))\n f.write(\"%ENDBLOCK LATTICE_CART\\n\")\n f.write(\"\\n\")\n f.write(\"%BLOCK POSITIONS_FRAC\\n\")\n k = 0\n for i in xrange(len(CASTEP_cell[\"numbers\"])):\n for j in xrange(CASTEP_cell[\"numbers\"][i]):\n l = k + j\n f.write(\"{0}\".format(\"\".join(CASTEP_cell[\"elements\"][i]))) \n f.write(\"{0[0]:>20.15f} {0[1]:>20.15f} {0[2]:>20.15f}\\n\".format(\n CASTEP_cell[\"positions\"][:,l].tolist()))\n k += j + 1\n f.write(\"%ENDBLOCK POSITIONS_FRAC\\n\")\n\n # Copy everything after '%ENDBLOCK POSITIONS_FRAC'\n for index, line in enumerate(castep_cell):\n if '%ENDBLOCK POSITIONS_FRAC' in line.upper():\n index_end = index\n for i in xrange(index_end+1,len(castep_cell)):\n f.write(castep_cell[i])\n with open(filename,\"w\") as finalf:\n finalf.write(f.getvalue())\n f.close()","def save_to_file(self, file_path):\n if file_path:\n f = open(file_path, 'w')\n for row in range(self.rows):\n f.write(''.join(self.data[row]) + '\\n')\n f.close()","def save_to_file(self, file_path):\n if file_path:\n f = open(file_path, 'w')\n for row in range(self.rows):\n f.write(''.join(self.data[row]) + '\\n')\n f.close()","def write_gds(self, outfile, cells=None, timestamp=None, binary_cells=None):\n close = True\n if hasattr(outfile, \"__fspath__\"):\n outfile = open(outfile.__fspath__(), \"wb\")\n elif isinstance(outfile, (basestring, Path)):\n outfile = open(outfile, \"wb\")\n else:\n close = False\n now = datetime.datetime.today() if timestamp is None else timestamp\n name = self.name if len(self.name) % 2 == 0 else (self.name + \"\\0\")\n outfile.write(\n struct.pack(\n \">5H12h2H\",\n 6,\n 0x0002,\n 0x0258,\n 28,\n 0x0102,\n now.year,\n now.month,\n now.day,\n now.hour,\n now.minute,\n now.second,\n now.year,\n now.month,\n now.day,\n now.hour,\n now.minute,\n now.second,\n 4 + len(name),\n 0x0206,\n )\n + name.encode(\"ascii\")\n + struct.pack(\">2H\", 20, 0x0305)\n + _eight_byte_real(self.precision / self.unit)\n + _eight_byte_real(self.precision)\n )\n if cells is None:\n cells = self.cells.values()\n else:\n cells = [self.cells.get(c, c) for c in cells]\n if len(cells) == 0:\n warnings.warn(\"[GDSPY] Creating a GDSII file without any cells.\")\n for cell in cells:\n cell.to_gds(outfile, self.unit / self.precision, timestamp=timestamp)\n if binary_cells is not None:\n for bc in binary_cells:\n outfile.write(bc)\n outfile.write(struct.pack(\">2H\", 4, 0x0400))\n if close:\n outfile.close()","def write(cls, experiment: Experiment):\n cls.__mutex.acquire()\n os.makedirs('./temp', exist_ok=True)\n worksheet = cls.__workbook.add_worksheet(experiment.name)\n for i, value in enumerate(experiment.values.items()):\n worksheet.write(0, i, value[0])\n worksheet.write_column(1, i, value[1])\n if experiment.model == 'accuracy':\n # cls.__add_accuracy_plot(worksheet, value)\n cls.test(worksheet, value)\n\n pass\n\n if experiment.model == 'performance':\n cls.test(worksheet, value)\n pass\n # cls.__add_accuracy_plot(worksheet, value)\n\n cls.__mutex.release()","def write(self, file_name, style=None):\n write_elongation(self, file_name, style=style)","def write(self, filename): # real signature unknown; restored from __doc__\n pass","def write_grid(self, file_path, fmt='%0.16g'):\n with open(file_path, 'w') as outfile:\n if self.grid.size == 3:\n outfile.write('{}\\t{}\\t{}\\n'.format(self.grid[0].size - 1,\n self.grid[1].size - 1,\n self.grid[2].size - 1))\n else:\n outfile.write('{}\\t{}\\n'.format(self.grid[0].size - 1,\n self.grid[1].size - 1))\n with open(file_path, 'ab') as outfile:\n numpy.savetxt(outfile, numpy.c_[self.grid[0]], fmt=fmt)\n numpy.savetxt(outfile, numpy.c_[self.grid[1]], fmt=fmt)\n if self.grid.size == 3:\n numpy.savetxt(outfile, numpy.c_[self.grid[2]], fmt=fmt)","def write_to_file(self, file):\n f = open(file, \"w+\")\n for row in self.value:\n line = \" \".join(str(el) for el in row) + \"\\n\"\n f.write(line)\n\n f.close()","def write_to_file(entry, file):\n with open(file, \"a\") as f:\n f.write(entry)","def write(self, filename, energy_unit='TeV', effarea_unit='m2',\n *args, **kwargs):\n self.to_fits(energy_unit=energy_unit, effarea_unit=effarea_unit).writeto(\n filename, *args, **kwargs)","def write2file(self, save_to):\n headerstyle = xlwt.easyxf(self.header_style.get_style_string())\n missing_val_style = xlwt.easyxf(\n self.missing_value_style.get_style_string())\n row_styles = [xlwt.easyxf(self.first_style.get_style_string()),\n xlwt.easyxf(self.second_style.get_style_string())]\n\n properties, sections, table = self._build_table()\n\n workbook = xlwt.Workbook()\n sheet = workbook.add_sheet(self.sheet_name)\n\n if os.path.splitext(save_to)[-1] == '':\n save_to += '.xls'\n\n max_col_len = []\n\n if (self.switch):\n\n for i, prop in enumerate([''] + properties):\n sheet.write(0, i, prop, headerstyle)\n max_col_len.append(len(str(prop)))\n\n for row_num, sec in enumerate(sections):\n sheet.write(row_num + 1, 0, sec, headerstyle)\n if len(str(sec)) > max_col_len[0]:\n max_col_len[0] = len(str(sec))\n\n for row_num, row in enumerate(table):\n for col_num, elem in enumerate(row):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n else:\n\n for i, sec in enumerate([''] + sections):\n sheet.write(0, i, sec, headerstyle)\n max_col_len.append(len(str(sec)))\n\n for row_num, prop in enumerate(properties):\n sheet.write(row_num + 1, 0, prop, headerstyle)\n if len(str(prop)) > max_col_len[0]:\n max_col_len[0] = len(str(prop))\n\n for col_num, col in enumerate(table):\n for row_num, elem in enumerate(col):\n\n if elem is None:\n style = missing_val_style\n cell_content = \"\"\n else:\n style = row_styles[row_num % 2]\n cell_content = elem\n\n if isinstance(cell_content, datetime.datetime):\n style.num_format_str = \"DD-MM-YYYY HH:MM:SS\"\n elif isinstance(cell_content, datetime.date):\n style.num_format_str = \"DD-MM-YYYY\"\n elif isinstance(cell_content, datetime.time):\n style.num_format_str = \"HH:MM:SS\"\n else:\n style.num_format_str = \"\"\n\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\n if len(str(cell_content)) > max_col_len[col_num+1]:\n max_col_len[col_num+1] = len(str(cell_content))\n\n # adjust width of he columns\n for col_id, col_len in enumerate(max_col_len):\n sheet.col(col_id).width = (256 * (col_len+1))\n\n workbook.save(save_to)","def render_sheet_to_file(self, file_name, sheet, **keywords):\n raise NotImplementedError(\"We are not writing to file\")","def write(self, block_no, value):\n with open(self.file_path, 'r+') as f:\n f.seek(block_no * config.block_size)\n f.write(value)","def write(self, filename, data):\n raise NotImplementedError","def write(self, filename, **kwargs):\n self.to_table().write(filename, format='fits', **kwargs)","def save(self, fname) -> None:\n\n ss = self.to_spreadsheet()\n ss.save(fname)","def write(self, filename):\n f = open(filename, 'w')\n f.write(str(self.m) + \"\\n\")\n f.write(str(self.n) + \"\\n\")\n for i in self.values:\n for j in i:\n f.write(str(j)+\"\\n\")\n f.closed","def save(self,outPath=None):\n if (not self.canSave or self.skipObjRecords): raise StateError(_(\"Insufficient data to write file.\"))\n if not outPath:\n fileInfo = self.fileInfo\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\n out = file(outPath,'wb')\n #--Tes3 Record\n self.tes3.changed = 1\n self.tes3.hedr.changed = 1\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\n self.tes3.getSize()\n self.tes3.dump(out)\n #--Size Cell Records\n cntRecords = 0\n progress = self.progress\n progress.setMax(len(self.cells))\n progress(0.0,'Saving '+self.fileInfo.name)\n for record in self.cells:\n record.getSize()\n #--Progress\n cntRecords += 1\n progress(cntRecords)\n #--Other Records\n for record in self.records:\n record.getSize() #--Should already be done, but just in case.\n record.dump(out)\n out.close()","def write(self, filename=None):\n if filename == None:\n filename = self.ofilename\n\n ofile = open(filename, 'w')\n\n ofile.write('# Susceptibility: %E d(susc): %E Coercivity: %E d(coer): %E\\n' % (self.susceptibility_mean, self.susceptibility_std, self.coercivity_mean, self.coercivity_std) )\n ofile.write('# H[] M[] Mfit[]\\n')\n\n #for i in range(len(self.h)):\n # ofile.write(\" %12.10f %12.10f %12.10f\\n\" % ( self.h[i], self.m[i], self.m_fit[i] ) )\n\n ofile.close()","def write_to(self, fname, **kwargs):\n data = self.to_Table()\n data.write(fname, **kwargs)","def write(filename):\n print(uc.write(filename))","def writeGP(loc, fname, data, header, ncol=6):\n size = len(data)\n nrow = int(size / ncol)\n size_last_row = size % ncol\n\n lines = \"\"\n for line in np.reshape(range(nrow * ncol), (nrow, ncol)):\n for val in line:\n lines += \"{:^20.6e}\".format(data[val]) + 3 * \" \"\n lines = lines.rstrip(3 * \" \") + \"\\n\"\n\n if size_last_row:\n for i in range(1, size_last_row + 1):\n lines += \"{:^20.6e}\".format(data[-i]) + 3 * \" \"\n lines = lines.rstrip(3 * \" \")\n\n with open(\"/\".join([loc, fname]), \"w\") as f:\n f.writelines(header)\n f.writelines(lines)\n return","def save_data(data, filename, path=\"\", cell=None):\n if cell is not None:\n with open((os.getcwd() + \"/results/{0}_{1}.json\").format(filename, cell), 'w') as f:\n json.dump(data, f, sort_keys=True, indent=4, separators=(',', ': '))\n else:\n with open((os.getcwd() + \"/results/{0}.json\").format(filename), 'w') as f:\n json.dump(data, f, sort_keys=True, indent=4, separators=(',', ': '))","def _write(self):\n # Reload\n with portalocker.Lock(self.filename, 'w') as fh:\n self.data.to_csv(fh, index=False)\n fh.flush()\n os.fsync(fh.fileno())","def write(cls, file, data):\n file.write(data)","def write_file(self):\n rl_df, lift_df = self.create_df()\n\n number = re.findall('\\d+', self.url)[0]\n\n if self.write is True:\n with open('house_{}.csv'.format(number), 'w',\n encoding='utf-8-sig') as file:\n rl_df.to_csv(file, sep=';')\n with open('house_lifts_{}.csv'.format(number), 'w',\n encoding='utf-8-sig') as file2:\n lift_df.to_csv(file2, sep=';')","def save_to_file(grid, filepath):\n outfile = codecs.open(filepath, mode='w+', encoding='utf-8')\n outfile.writelines([((''.join(row)) + u'\\n') for row in grid])","def write(self, cw, message):\n if cw in self.location:\n fn = self.location[str(cw)]\n try:\n swf = open(fn, \"w\")\n except Exception:\n logmsg.update(\"Error writing to file \" + fn + \"!\", 'E')\n else:\n swf.write(str(message))\n swf.close()\n else:\n logmsg.update(\"Wrong target [\" + str(cw) + \"] for saving file!\", 'E')","def test_write_data(workbook):\n workbook.write_data(\"example data\")\n assert workbook.get_cell(workbook.get_last_row(), 1) == \"example data\"","def write_to_binary_file(self, filename):\n\n self.octree.writeBinary(str.encode(filename))","def file_write(stuff, file_path):\n with open(file_path, \"wt\") as fo:\n fo.write(stuff)","def write_file(self):\r\n # -open file for writing\r\n f_fbob = open(self.fn_path, 'w')\r\n\r\n # -write header\r\n f_fbob.write('%s\\n' % (self.heading))\r\n\r\n # -write sections 1 & 2 : NOTE- what about NOPRINT?\r\n f_fbob.write('%10i%10i%10i%10i\\n' % (self.nqfb, self.nqcfb,\r\n self.nqtfb, self.iufbobsv))\r\n f_fbob.write('%10e\\n' % (self.tomultfb)) # check format\r\n\r\n # -write sections 3-5 looping through observations groups\r\n c = 0\r\n for i in range(self.nqfb):\r\n # while (i < self.nqfb):\r\n # write section 3\r\n f_fbob.write('{:10d}{:10d}\\n'.format(self.nqobfb[i],\r\n self.nqclfb[i]))\r\n\r\n # Loop through observation times for the groups\r\n for j in range(self.nqobfb[i]):\r\n # -write section 4\r\n f_fbob.write(\r\n '{}{:10d}{:10.4g}{}{:10.4g}\\n'.format(self.obsnam[c],\r\n self.irefsp[c],\r\n self.toffset[c], ' ',\r\n self.flwobs[c]))\r\n c += 1 # index variable\r\n\r\n # -write section 5 - NOTE- need to adjust factor for muliple obs same cell\r\n for j in range(abs(self.nqclfb[i])):\r\n if self.nqclfb[\r\n i] < 0: # set factor to 1.0 for all cells in group\r\n self.factor[i, :] = 1.0\r\n f_fbob.write('{:10d}{:10d}{:10d}{}{:10f}\\n'\r\n .format(self.layer[i, j], (self.row[i, j]),\r\n self.column[i, j],\r\n ' ', self.factor[\r\n i, j])) # note- is 10f good enough here?\r\n\r\n f_fbob.close()\r\n #\r\n # swm: BEGIN hack for writing standard file\r\n sfname = self.fn_path # swm:hack\r\n sfname += '_ins' # swm: hack\r\n # write header\r\n f_ins = open(sfname, 'w') # swm: hack for standard file\r\n f_ins.write('jif @\\n') # swm: hack for standard file\r\n f_ins.write('StandardFile 0 1 %s\\n' % (\r\n self.nqtfb)) # swm: hack for standard file\r\n for i in range(0, self.nqtfb):\r\n f_ins.write(\r\n '{}\\n'.format(self.obsnam[i])) # swm: hack for standard file\r\n\r\n f_ins.close()\r\n # swm: END hack for writing standard file\r\n\r\n return","def write_to_file(board, output_file = \"solution.sud\"):\n with open(output_file, \"w\") as f:\n for i in range(n):\n if i and i%3==0:\n f.write(\"------+-------+------\\n\")\n for j in range(n): \n if j and j%3==0:\n f.write(\"| \")\n if len(board[i][j]) == 1:\n f.write(str(board[i][j][0]) + \" \")\n else:\n f.write(\". \")\n elif j==8:\n if len(board[i][j]) == 1:\n f.write(str(board[i][j][0]) + \"\\n\")\n else:\n f.write(\".\\n\")\n else:\n if len(board[i][j]) == 1:\n f.write(str(board[i][j][0]) + \" \")\n else:\n f.write(\". \")\n return 0","def write_to_file(self, filename):\n self.octree.write(str.encode(filename))\n print(\"Save octomap to \"+filename)","def write (self, file):\n\t\tfile.write (self.pack ())","def _save_chromosome_at_index(self, index, file_name):\n how_to_open = 'w' if index == 0 else 'a'\n with open(file_name, how_to_open) as out_file:\n for category in self.population[index].get_genes():\n out_file.write(''.join(category) + '\\t')\n out_file.write(\n '\\n{}\\n'.format(self.population[index].get_fitness())\n )","def save_EGRID( self , filename , output_unit = EclUnitTypeEnum.ERT_ECL_METRIC_UNITS):\n self._fwrite_EGRID2( filename, output_unit )","def write_table(self, G, myfile):\r\n self.node_table(G, myfile)\r\n self.edge_table(G, myfile)\r\n return myfile","def write_binary_cells(self, binary_cells):\n for bc in binary_cells:\n self._outfile.write(bc)\n return self","def exportPlayground(self, filepath):\n cellPositions = \"\"\n for cell in self.cells:\n if(cell.dead == False):\n cellPositions += str(cell.x) + \" \" + str(cell.y) + \"\\n\"\n \n fileWrite = open(filepath, \"w\")\n fileWrite.write(cellPositions)\n fileWrite.close()","def saveOnFile(self, path, data):\n with open(path, \"w\") as f:\n f.write(data)","def write(self, filename):\n with open(filename, \"w\") as f:\n f.write(self.get_string())","def write(self, filename):\n with open(filename, \"w\") as f:\n f.write(self.get_string())","def __writeElement(fd, elm):\n\n print(\n \" <td>\",\n \" <h4>\" + elm[\"name\"] + \"</h4>\",\n \" <ul>\",\n \" <li>\" + str(elm[\"number\"]) + \"</li>\",\n \" <li>\" + elm[\"small\"] + \"</li>\",\n \" <li>\" + str(elm[\"molar\"]) + \"</li>\",\n \" </ul>\",\n \" </td>\",\n sep=\"\\n\",\n file=fd\n )","def write(self, quit_app=False):\n self._app[\"statusbar\"].message(\"Saving...\", \"info\")\n # Manipulations include transformations implicitly\n if self._app[\"manipulate\"].is_visible():\n self._app[\"manipulate\"].finish(True)\n self._changes.clear()\n # Only apply any transformations\n else:\n self._thread_for_apply()\n # Quit or inform\n if quit_app:\n self._app.quit_wrapper()\n else:\n self._app[\"statusbar\"].message(\"Changes written to disk\", \"info\")","def write():\n pass","def write(self, arg, **kwargs):\r\n if hasattr(arg, 'seek'):\r\n self._tofile(arg, **kwargs)\r\n else:\r\n with open(arg, 'wb') as fid:\r\n self._tofile(fid, **kwargs)","def write(self, row):\n bytes = struct.pack(self.pack_format, *row)\n self.f.write(bytes)","def write_elongation(elongation, file_name, style=None):\n style = file_name.split('.')[-1] if style is None else style\n\n if style == 'csv':\n write_csv(elongation, file_name)\n elif style == 'prn':\n raise NotImplementedError()\n else:\n raise NotImplementedError()","def write(self, val, prefix, args=()):\n file_path = self.path(prefix, args)\n val_str = self.writer_(val)\n autofile.write_file(file_path, val_str)","def write(self, filename, *args, **kwargs):\n self.to_fits().writeto(filename, *args, **kwargs)","def write(self, path):\n # if file doesn't already exist, write column names in a header\n if not os.path.exists(path):\n with open(path, 'a+') as f:\n f.write('# {}# time,status,dphi,umolar,mbar,airSat,tempSample,tempCase,signalIntensity,ambientLight,pressure,humidity,resistorTemp,percentO2\\n'.format(self.label))\n # generate out_str\n if isinstance(self.last_read[0], list):\n out_str = ''\n for r in self.last_read:\n out_str += fmt(r, 1, ',') + '\\n'\n else:\n out_str = fmt(self.last_read, 1, ',') + '\\n'\n # write and save data\n self.write_str = out_str\n with open(path, 'a+') as f:\n f.write(out_str)\n return","def writeto(self, filename, overwrite=True, **kwargs):\n from astropy.io import fits\n return fits.writeto( filename, self.data, header=self.header,\n overwrite=overwrite, **kwargs)","def write(self, filename, filepath, overwrite=True):\n super().write(filename, filepath, overwrite)\n try:\n with open(filename, 'w') as output:\n output.write(str(self._formatter))\n except IOError as e:\n print(type(e))\n print(e.args)\n print(e)","def write_binary(self, path):\n return","def FileWrite(offset, buf):\r\n return _hiew.HiewGate_FileWrite(offset, buf)","def _write(i):\n try:\n spreadsheet = _get_spreadsheet(i)\n except IOError:\n msg = '{} parties spreadsheet not found'.format(i.canonical_name)\n logger.log_warning(msg)\n else:\n content = _get_content(i, spreadsheet)\n if content:\n _write_content(i, content)","def write_to_file(filepath, data):\n\n with open(filepath, 'w') as f:\n f.write(str(data))","def write(self):\n\t\traise NotImplementedError('%s: No write function implemented!' % self.name)","def writeFile(filename):\n\n with open(filename, \"w\") as f:\n Write.__writeHeader(f)\n\n Write.__openRow(f)\n i = 0\n for elm in Parse.data:\n while i != elm[\"position\"]:\n Write.__writeEmptyElement(f)\n i += 1\n\n Write.__writeElement(f, elm)\n i += 1\n\n if elm[\"position\"] == 17:\n i = 0\n Write.__closeRow(f)\n if elm[\"number\"] != 118:\n Write.__openRow(f)\n\n Write.__writeFooter(f)","def save_to(self, f: BinaryIO):\n raise NotImplementedError","def write_to_file(filename, content):\n with open(filename, 'w') as f:\n f.write(content)","def output_1cell(self, filename):\n\n date_concat = \"{0} to {1}\".format(self.startDate, self.endDate)\n if active_restaurant_loop:\n column_name = [\"range\", \"start_date\",\n \"end_date\", \"location_id\", \"content\"]\n data = [date_concat, self.startDate, self.endDate, str(\n self.payload[\"locationGroupID\"]), \"{0}\".format(self.content)]\n data_out = [column_name, data]\n else:\n column_name = [\"range\", \"start_date\", \"end_date\", \"content\"]\n data = [date_concat, self.startDate,\n self.endDate, \"{0}\".format(self.content)]\n data_out = [column_name, data]\n\n # If active restaurant loop is true\n if not os.path.isfile(filename):\n with open(filename, \"w\") as f:\n writer = csv.writer(f)\n #writer.writerow([\"range\", \"start_date\", \"end_date\", \"content\"])\n #writer.writerow([date_concat, start_date, end_date, \"{0}\".format(self.content)])\n writer.writerows(data_out)\n # f.write([\"content\"])\n # f.write([\"{0}\"].format(self.content))\n f.close()\n else:\n with open(filename, \"a\") as f:\n writer = csv.writer(f)\n writer.writerows([data])\n f.close()\n\n logging.info(\"Outputting... \")\n self.produce_manifest(filename)","def write(self, data_to_write):\n self.single_file.write(data_to_write)\n self.single_file.flush()","def _write(self, data):\n self._writer.write(data)","def write_shapefile(self, filename='grid.shp', epsg=None, prj=None):\n from ..export.shapefile_utils import write_grid_shapefile2\n if epsg is None and prj is None:\n epsg = self.epsg\n write_grid_shapefile2(filename, self, array_dict={}, nan_val=-1.0e9,\n epsg=epsg, prj=prj)","def write_field(self,filename,field,griddescfile=None,fieldname=None):\n\n pass","def set_cell(self, cell, val):\n a = b = 0\n try:\n a, b = self.__ret_cell(cell)\n self._grid[a][b] = val\n except IndexError as e:\n self.perror(\"Error: '%s'.\" % e, cell, a, b, 5)\n self.perror(\"Error.\", cell, a, b, 5)\n sys.exit()","def write(self, outfile):\n outfile.write(\n '\\t'.join(\n [\n str(i) for i in [\n self.chrom, self.start, self.end, self.name,\n self.count, self.fold_change, self.log10p\n ]\n ]\n )\n )\n outfile.write('\\n')","def writeToFile(self):\n self.dto.writeToCsv()\n print(\"File written.\")","def write_ptm_gridfile(self,fn):\n vertex_hdr = \" Vertex Data: vertex_number, x, y\"\n poly_hdr = \" Polygon Data: polygon_number, number_of_sides,center_x, center_y, center_depth, side_indices(number_of_sides), marker(0=internal,1=open boundary)\"\n side_hdr = \" Side Data: side_number, side_depth, node_indices(2), cell_indices(2), marker(0=internal,1=external,2=flow boundary,3=open boundary)\"\n\n with open(fn,'wt') as fp:\n # write header counts\n fp.write(\" Number of Vertices\\n\")\n fp.write(\" %20d\\n\"%self.Nnodes())\n fp.write(\" Number of Polygons\\n\")\n fp.write(\" %20d\\n\"%self.Ncells())\n fp.write(\" Number of Sides\\n\")\n fp.write(\" %20d\\n\"%self.Nedges())\n fp.write(\" NODATA (land) value\\n\")\n fp.write(\" -9999.000000000\\n\")\n\n # write vertex info\n fp.write(vertex_hdr+\"\\n\")\n for v in range(self.Nnodes()):\n fp.write(\" %10d %16.7f %16.7f\\n\"%(v+1,\n self.nodes['x'][v,0],\n self.nodes['x'][v,1]))\n\n # write polygon info\n fp.write(poly_hdr+\"\\n\")\n cell_write_str1 = \" %10d %10d %16.7f %16.7f %16.7f \"\n cell_depths = self.cell_depths()\n for e in range(self.Ncells()):\n edges = self.cells['edges'][e,:]\n edges[edges<0] = -1\n edge_str = \" \".join( [\"%10d\"%(s+1) for s in edges] )\n edge_str = edge_str+\" %10d\\n\"%(self.cells['mark'][e])\n nsides = sum(edges>=0)\n fp.write(cell_write_str1%(e+1,\n nsides,\n self.cells['_center'][e,0],\n self.cells['_center'][e,1],\n cell_depths[e]))\n fp.write(edge_str)\n \n # write side info\n fp.write(side_hdr+\"\\n\")\n edge_depths = self.edge_depths()\n edge_write_str = \" %10d %16.7f %10d %10d %10d %10d %10d\\n\"\n for s in range(self.Nedges()):\n edges = self.edges['cells'][s,:]\n edges[edges<0] = -1 \n nodes = self.edges['nodes'][s,:]\n nodes[nodes<0] = -1\n fp.write(edge_write_str%(s+1,\n edge_depths[s],\n nodes[0]+1,\n nodes[1]+1,\n edges[0]+1,\n edges[1]+1,\n self.edges['mark'][s]))","def writeRowToFile(filename, row):\n try:\n with open(filename,'a',newline='') as f:\n row_writer = csv.writer(f)\n row_writer.writerow(row)\n except:\n with open('error_log.csv','a', newline='') as error_f:\n print('Error writing to file')\n row_writer = csv.writer(error_f)\n row_writer.writerow(row)","def __write_place(self, handle, nbr):\n try:\n place = self.database.get_place_from_handle(handle)\n self.__write_row(nbr, handle, place)\n except:\n place = \"NOT FOUND\"\n self.__write_row(nbr, handle, place)","def write(self, data):\n return self._write(self.wfile, data)"],"string":"[\n \"def write_cell(self, cell):\\n self._outfile.write(cell.to_gds(self._res))\\n return self\",\n \"def writeCell(hoja, fila, columna, dato, formato=''):\\r\\n if formato:\\r\\n hoja.write(fila, columna, dato, formato)\\r\\n else:\\r\\n hoja.write(fila, columna, dato)\",\n \"def write_cell(self, sheet_name, row, column, value, color='black'):\\n if isinstance(row, int) and isinstance(column, int):\\n try:\\n cell_obj = self.wb[sheet_name].cell(row, column)\\n cell_obj.font = Font(color=self.RGBDict[color], bold=True)\\n cell_obj.value = value\\n self.wb.save(self.filename)\\n logger.info(\\\"Excel文件[{}]表单[{}]写入数据[{}]\\\".format(self.filename, sheet_name, value))\\n except Exception as e:\\n logger.error(\\\"Excel文件[{}]表单[{}]写入数据错误\\\\n错误信息:{}\\\".format(self.filename, sheet_name, e))\\n raise e\\n else:\\n logger.error(\\\"Excel文件写入数据错误\\\\n错误信息:{}\\\".format('row and column must be type int'))\\n raise TypeError('row and column must be type int')\",\n \"def write(self, fname):\\n pass\",\n \"def setOutCell(outSheet, col, row, value):\\n\\n def _getOutCell(outSheet, colIndex, rowIndex):\\n \\\"\\\"\\\" HACK: Extract the internal xlwt cell representation. \\\"\\\"\\\"\\n row = outSheet._Worksheet__rows.get(rowIndex)\\n if not row: return None\\n\\n cell = row._Row__cells.get(colIndex)\\n return cell\\n\\n # HACK to retain cell style.\\n previousCell = _getOutCell(outSheet, col, row)\\n # END HACK, PART I\\n\\n outSheet.write(row, col, value)\\n\\n # HACK, PART II\\n if previousCell:\\n newCell = _getOutCell(outSheet, col, row)\\n if newCell:\\n newCell.xf_idx = previousCell.xf_idx\\n # END HACK\",\n \"def write(self, filename):\\n pass\",\n \"def write(self, filename):\\n pass\",\n \"def write_to_file(self, filename: str) -> None:\",\n \"def cell_file(self, filename, append=False):\\n if filename.startswith(\\\"~\\\"):\\n filename = os.path.expanduser(filename)\\n filename = os.path.abspath(filename)\\n # Create the path of the file if dirs don't exist:\\n path = os.path.dirname(os.path.abspath(filename))\\n try:\\n os.makedirs(path)\\n except OSError as exc: # Python >2.5\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\\n # Create or append to file:\\n if not append:\\n message = \\\"Created file '%s'.\\\" % filename\\n if os.path.isfile(self.code):\\n message = \\\"Overwrote file '%s'.\\\" % filename\\n else:\\n message = \\\"Appended on file '%s'.\\\" % filename\\n try:\\n if append:\\n fp = open(filename, \\\"a\\\")\\n else:\\n fp = open(filename, \\\"w\\\")\\n fp.write(self.code)\\n fp.close()\\n self.kernel.Print(message)\\n except Exception as e:\\n self.kernel.Error(str(e))\\n self.evaluate = False\",\n \"def write_gds(self, outfile, cells=None, timestamp=None):\\n if isinstance(outfile, basestring):\\n outfile = open(outfile, 'wb')\\n close = True\\n else:\\n close = False\\n now = datetime.datetime.today() if timestamp is None else timestamp\\n name = self.name if len(self.name) % 2 == 0 else (self.name + '\\\\0')\\n outfile.write(\\n struct.pack('>19h', 6, 0x0002, 0x0258, 28, 0x0102, now.year,\\n now.month, now.day, now.hour, now.minute, now.second,\\n now.year, now.month, now.day, now.hour, now.minute,\\n now.second, 4 + len(name), 0x0206) +\\n name.encode('ascii') + struct.pack('>2h', 20, 0x0305) +\\n _eight_byte_real(self.precision / self.unit) +\\n _eight_byte_real(self.precision))\\n if cells is None:\\n cells = self.cell_dict.values()\\n else:\\n cells = [self.cell_dict.get(c, c) for c in cells]\\n for cell in cells:\\n outfile.write(cell.to_gds(self.unit / self.precision))\\n outfile.write(struct.pack('>2h', 4, 0x0400))\\n if close:\\n outfile.close()\",\n \"def write_to_cell(table, row, col, text):\\n\\n\\ttable.cell(row, col).paragraphs[0].runs[0].text = text\",\n \"def write_towhee_coord(self, filename):\\n with open(filename, 'w') as f:\\n df = self.contents[['X', 'Y', 'Z']].copy()\\n np.savetxt(f, df.values, fmt=\\\" %20.15f\\\"*3)\",\n \"def write_file(self):\\n if self._write_file == None:\\n return\\n\\n try:\\n out = file(self._write_file, \\\"w\\\")\\n except IOError, e:\\n print e\\n sys.exit(1)\\n out.writelines(\\\"A cases\\\") \\n out.close()\",\n \"def writetofile(self,direction,value):\\r\\n output = str(\\\"{},{} \\\\n\\\".format(direction,value))\\r\\n self.new_file.write(output)\",\n \"def save_GRID( self , filename ):\\n self._fwrite_GRID( filename )\",\n \"def w(self, value):\\n self.oFile.write(value)\",\n \"def write( self, NewFilename='', Integer=True ):\\n try:\\n if NewFilename != '':\\n self.name=NewFilename\\n Output = open( self.name, 'w' )\\n Output.write( 'ncols\\\\t\\\\t %d\\\\n' % self.ncols )\\n Output.write( 'nrows\\\\t\\\\t %d\\\\n' % self.nrows )\\n Output.write( 'xllcorner\\\\t\\\\t %f\\\\n' % self.xllcorner)\\n Output.write( 'yllcorner\\\\t\\\\t %f\\\\n' % self.yllcorner)\\n Output.write( 'cellsize\\\\t\\\\t %f\\\\n' % self.cellsize)\\n if Integer:\\n Output.write( 'NODATA_value\\\\t\\\\t %d\\\\n' % int(self.nodata) )\\n else:\\n Output.write( 'NODATA_value\\\\t\\\\t %f\\\\n' % self.nodata )\\n for row in range( self.nrows-1,-1,-1 ):\\n record = []\\n for col in range( self.ncols ):\\n if Integer:\\n record.append( str( int( round( self.data[row,col]) ) ) )\\n else:\\n record.append( str(self.data[row,col]) )\\n Output.write( string.join(record, ' ')+'\\\\n' )\\n Output.close()\\n except:\\n print \\\"Error writing grid ::\\\", self.name\",\n \"def setCell(self, row = None, column = None, value = None, *, cell = None):\\n\\n\\t\\t\\t\\tif (cell is None):\\n\\t\\t\\t\\t\\tcell = self.getCell(row = row, column = column)\\n\\n\\t\\t\\t\\tif (value is None):\\n\\t\\t\\t\\t\\tvalue = \\\"\\\"\\n\\n\\t\\t\\t\\t#Write Value\\n\\t\\t\\t\\tfor _cell in self.ensure_container(cell):\\n\\t\\t\\t\\t\\t_cell.value = f\\\"{value}\\\" #Make sure input is a valid ascii\",\n \"def filewrite(self, filename):\\n io.write(self, filename)\",\n \"def write_file(file_name, table):\\r\\n \\r\\n savectr=len(table)\\r\\n try:\\r\\n with open (file_name, 'wb') as objFile:\\r\\n pickle.dump(table,objFile) #pickle my 2D list\\r\\n print ('{} CD(s) saved into {}.\\\\n'.format(savectr,file_name))\\r\\n except PermissionError as e:\\r\\n print('Not enough rights to create/modify ' + file_name + '.') #if unable pickle data due to permission issues\\r\\n print ()\\r\\n print (e, e.__doc__, sep='\\\\n')\\r\\n print ()\\r\\n except IOError as e:\\r\\n print ('I/O error({0}): {1}'.format(e.errno,e.strerror))#if unable to pickle data due to IO errors such as disk space issues\\r\\n print ()\\r\\n print (e, e.__doc__, sep='\\\\n')\\r\\n print ()\\r\\n except pickle.PickleError as e:\\r\\n print ('Unable to write data into ' + file_name + '.') #if unable to pickle 2D list, exception handling for pickling errors\\r\\n print ()\\r\\n print (e, e.__doc__, sep='\\\\n')\\r\\n print ()\",\n \"def write_to_file(self, time):\\n if Parameters.instance().use_ages:\\n nb_age_groups = len(Parameters.instance().age_proportions)\\n else:\\n nb_age_groups = 1\\n if Parameters.instance().use_ages:\\n if self.spatial_output: # Separate output line for each cell\\n for cell in self.population.cells:\\n for age_i in range(0, nb_age_groups):\\n data = {s: 0 for s in list(InfectionStatus)}\\n for inf_status in data:\\n data_per_inf_status =\\\\\\n cell.compartment_counter.retrieve()[inf_status]\\n data[inf_status] += data_per_inf_status[age_i]\\n # Age groups are numbered from 1 to the total number\\n # of age groups (thus the +1):\\n data[\\\"age_group\\\"] = age_i+1\\n data[\\\"time\\\"] = time\\n data[\\\"cell\\\"] = cell.id\\n data[\\\"location_x\\\"] = cell.location[0]\\n data[\\\"location_y\\\"] = cell.location[1]\\n self.writer.write(data)\\n else: # Summed output across all cells in population\\n data = {s: 0 for s in list(InfectionStatus)}\\n for cell in self.population.cells:\\n for age_i in range(0, nb_age_groups):\\n for inf_status in list(InfectionStatus):\\n data_per_inf_status =\\\\\\n cell.compartment_counter.retrieve()[inf_status]\\n data[inf_status] += data_per_inf_status[age_i]\\n data[\\\"age_group\\\"] = age_i+1\\n data[\\\"time\\\"] = time\\n self.writer.write(data)\\n else: # If age not considered, age_group not written in csv\\n if self.spatial_output: # Separate output line for each cell\\n for cell in self.population.cells:\\n data = {s: 0 for s in list(InfectionStatus)}\\n for k in data:\\n data[k] += sum(cell.compartment_counter.retrieve()[k])\\n data[\\\"time\\\"] = time\\n data[\\\"cell\\\"] = cell.id\\n data[\\\"location_x\\\"] = cell.location[0]\\n data[\\\"location_y\\\"] = cell.location[1]\\n self.writer.write(data)\\n else: # Summed output across all cells in population\\n data = {s: 0 for s in list(InfectionStatus)}\\n for cell in self.population.cells:\\n for k in data:\\n # Sum across age compartments\\n data[k] += sum(cell.compartment_counter.retrieve()[k])\\n data[\\\"time\\\"] = time\\n self.writer.write(data)\",\n \"def write_table(table, file_path):\\n\\n\\twith open(file_path, 'w') as file:\\n\\t\\tfile.write(table)\",\n \"def write_to(self, filename):\\n with open(filename, 'w') as f:\\n for xx, yy, zz, ww in zip(self.x, self.y, self.field, self.weight):\\n f.write(\\\"%s %s %s %s\\\\n\\\" % (xx, yy, zz, ww))\\n logger.info(\\\"Written data into file {0}\\\".format(filename))\",\n \"def write_to_file(fib_details: dict):\\n pass # TODO: Replace with implementation!\",\n \"def write_to_sheet(self):\\n for i, row in enumerate(self.ws[self.range_name]):\\n if isinstance(self.data[i], tuple):\\n self.data[i] = list(self.data[i])\\n for j, cell in enumerate(row):\\n cell.value = self.data[i][j]\",\n \"def write_CASTEP_cell(CASTEP_cell,filename):\\n f=open(seedname+\\\".cell\\\",\\\"r\\\")\\n castep_cell = f.readlines()\\n global hashes\\n f=StringIO.StringIO()\\n f.write(\\\"%BLOCK LATTICE_CART\\\\n\\\")\\n for i in xrange(3):\\n f.write(\\\"{0[0]:>20.15f} {0[1]:>20.15f} {0[2]:>20.15f}\\\\n\\\".format(\\n (CASTEP_cell[\\\"lattvec\\\"][:,i]*10).tolist()))\\n f.write(\\\"%ENDBLOCK LATTICE_CART\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"%BLOCK POSITIONS_FRAC\\\\n\\\")\\n k = 0\\n for i in xrange(len(CASTEP_cell[\\\"numbers\\\"])):\\n for j in xrange(CASTEP_cell[\\\"numbers\\\"][i]):\\n l = k + j\\n f.write(\\\"{0}\\\".format(\\\"\\\".join(CASTEP_cell[\\\"elements\\\"][i]))) \\n f.write(\\\"{0[0]:>20.15f} {0[1]:>20.15f} {0[2]:>20.15f}\\\\n\\\".format(\\n CASTEP_cell[\\\"positions\\\"][:,l].tolist()))\\n k += j + 1\\n f.write(\\\"%ENDBLOCK POSITIONS_FRAC\\\\n\\\")\\n\\n # Copy everything after '%ENDBLOCK POSITIONS_FRAC'\\n for index, line in enumerate(castep_cell):\\n if '%ENDBLOCK POSITIONS_FRAC' in line.upper():\\n index_end = index\\n for i in xrange(index_end+1,len(castep_cell)):\\n f.write(castep_cell[i])\\n with open(filename,\\\"w\\\") as finalf:\\n finalf.write(f.getvalue())\\n f.close()\",\n \"def save_to_file(self, file_path):\\n if file_path:\\n f = open(file_path, 'w')\\n for row in range(self.rows):\\n f.write(''.join(self.data[row]) + '\\\\n')\\n f.close()\",\n \"def save_to_file(self, file_path):\\n if file_path:\\n f = open(file_path, 'w')\\n for row in range(self.rows):\\n f.write(''.join(self.data[row]) + '\\\\n')\\n f.close()\",\n \"def write_gds(self, outfile, cells=None, timestamp=None, binary_cells=None):\\n close = True\\n if hasattr(outfile, \\\"__fspath__\\\"):\\n outfile = open(outfile.__fspath__(), \\\"wb\\\")\\n elif isinstance(outfile, (basestring, Path)):\\n outfile = open(outfile, \\\"wb\\\")\\n else:\\n close = False\\n now = datetime.datetime.today() if timestamp is None else timestamp\\n name = self.name if len(self.name) % 2 == 0 else (self.name + \\\"\\\\0\\\")\\n outfile.write(\\n struct.pack(\\n \\\">5H12h2H\\\",\\n 6,\\n 0x0002,\\n 0x0258,\\n 28,\\n 0x0102,\\n now.year,\\n now.month,\\n now.day,\\n now.hour,\\n now.minute,\\n now.second,\\n now.year,\\n now.month,\\n now.day,\\n now.hour,\\n now.minute,\\n now.second,\\n 4 + len(name),\\n 0x0206,\\n )\\n + name.encode(\\\"ascii\\\")\\n + struct.pack(\\\">2H\\\", 20, 0x0305)\\n + _eight_byte_real(self.precision / self.unit)\\n + _eight_byte_real(self.precision)\\n )\\n if cells is None:\\n cells = self.cells.values()\\n else:\\n cells = [self.cells.get(c, c) for c in cells]\\n if len(cells) == 0:\\n warnings.warn(\\\"[GDSPY] Creating a GDSII file without any cells.\\\")\\n for cell in cells:\\n cell.to_gds(outfile, self.unit / self.precision, timestamp=timestamp)\\n if binary_cells is not None:\\n for bc in binary_cells:\\n outfile.write(bc)\\n outfile.write(struct.pack(\\\">2H\\\", 4, 0x0400))\\n if close:\\n outfile.close()\",\n \"def write(cls, experiment: Experiment):\\n cls.__mutex.acquire()\\n os.makedirs('./temp', exist_ok=True)\\n worksheet = cls.__workbook.add_worksheet(experiment.name)\\n for i, value in enumerate(experiment.values.items()):\\n worksheet.write(0, i, value[0])\\n worksheet.write_column(1, i, value[1])\\n if experiment.model == 'accuracy':\\n # cls.__add_accuracy_plot(worksheet, value)\\n cls.test(worksheet, value)\\n\\n pass\\n\\n if experiment.model == 'performance':\\n cls.test(worksheet, value)\\n pass\\n # cls.__add_accuracy_plot(worksheet, value)\\n\\n cls.__mutex.release()\",\n \"def write(self, file_name, style=None):\\n write_elongation(self, file_name, style=style)\",\n \"def write(self, filename): # real signature unknown; restored from __doc__\\n pass\",\n \"def write_grid(self, file_path, fmt='%0.16g'):\\n with open(file_path, 'w') as outfile:\\n if self.grid.size == 3:\\n outfile.write('{}\\\\t{}\\\\t{}\\\\n'.format(self.grid[0].size - 1,\\n self.grid[1].size - 1,\\n self.grid[2].size - 1))\\n else:\\n outfile.write('{}\\\\t{}\\\\n'.format(self.grid[0].size - 1,\\n self.grid[1].size - 1))\\n with open(file_path, 'ab') as outfile:\\n numpy.savetxt(outfile, numpy.c_[self.grid[0]], fmt=fmt)\\n numpy.savetxt(outfile, numpy.c_[self.grid[1]], fmt=fmt)\\n if self.grid.size == 3:\\n numpy.savetxt(outfile, numpy.c_[self.grid[2]], fmt=fmt)\",\n \"def write_to_file(self, file):\\n f = open(file, \\\"w+\\\")\\n for row in self.value:\\n line = \\\" \\\".join(str(el) for el in row) + \\\"\\\\n\\\"\\n f.write(line)\\n\\n f.close()\",\n \"def write_to_file(entry, file):\\n with open(file, \\\"a\\\") as f:\\n f.write(entry)\",\n \"def write(self, filename, energy_unit='TeV', effarea_unit='m2',\\n *args, **kwargs):\\n self.to_fits(energy_unit=energy_unit, effarea_unit=effarea_unit).writeto(\\n filename, *args, **kwargs)\",\n \"def write2file(self, save_to):\\n headerstyle = xlwt.easyxf(self.header_style.get_style_string())\\n missing_val_style = xlwt.easyxf(\\n self.missing_value_style.get_style_string())\\n row_styles = [xlwt.easyxf(self.first_style.get_style_string()),\\n xlwt.easyxf(self.second_style.get_style_string())]\\n\\n properties, sections, table = self._build_table()\\n\\n workbook = xlwt.Workbook()\\n sheet = workbook.add_sheet(self.sheet_name)\\n\\n if os.path.splitext(save_to)[-1] == '':\\n save_to += '.xls'\\n\\n max_col_len = []\\n\\n if (self.switch):\\n\\n for i, prop in enumerate([''] + properties):\\n sheet.write(0, i, prop, headerstyle)\\n max_col_len.append(len(str(prop)))\\n\\n for row_num, sec in enumerate(sections):\\n sheet.write(row_num + 1, 0, sec, headerstyle)\\n if len(str(sec)) > max_col_len[0]:\\n max_col_len[0] = len(str(sec))\\n\\n for row_num, row in enumerate(table):\\n for col_num, elem in enumerate(row):\\n\\n if elem is None:\\n style = missing_val_style\\n cell_content = \\\"\\\"\\n else:\\n style = row_styles[row_num % 2]\\n cell_content = elem\\n\\n if isinstance(cell_content, datetime.datetime):\\n style.num_format_str = \\\"DD-MM-YYYY HH:MM:SS\\\"\\n elif isinstance(cell_content, datetime.date):\\n style.num_format_str = \\\"DD-MM-YYYY\\\"\\n elif isinstance(cell_content, datetime.time):\\n style.num_format_str = \\\"HH:MM:SS\\\"\\n else:\\n style.num_format_str = \\\"\\\"\\n\\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\\n if len(str(cell_content)) > max_col_len[col_num+1]:\\n max_col_len[col_num+1] = len(str(cell_content))\\n\\n else:\\n\\n for i, sec in enumerate([''] + sections):\\n sheet.write(0, i, sec, headerstyle)\\n max_col_len.append(len(str(sec)))\\n\\n for row_num, prop in enumerate(properties):\\n sheet.write(row_num + 1, 0, prop, headerstyle)\\n if len(str(prop)) > max_col_len[0]:\\n max_col_len[0] = len(str(prop))\\n\\n for col_num, col in enumerate(table):\\n for row_num, elem in enumerate(col):\\n\\n if elem is None:\\n style = missing_val_style\\n cell_content = \\\"\\\"\\n else:\\n style = row_styles[row_num % 2]\\n cell_content = elem\\n\\n if isinstance(cell_content, datetime.datetime):\\n style.num_format_str = \\\"DD-MM-YYYY HH:MM:SS\\\"\\n elif isinstance(cell_content, datetime.date):\\n style.num_format_str = \\\"DD-MM-YYYY\\\"\\n elif isinstance(cell_content, datetime.time):\\n style.num_format_str = \\\"HH:MM:SS\\\"\\n else:\\n style.num_format_str = \\\"\\\"\\n\\n sheet.write(row_num + 1, col_num + 1, cell_content, style)\\n if len(str(cell_content)) > max_col_len[col_num+1]:\\n max_col_len[col_num+1] = len(str(cell_content))\\n\\n # adjust width of he columns\\n for col_id, col_len in enumerate(max_col_len):\\n sheet.col(col_id).width = (256 * (col_len+1))\\n\\n workbook.save(save_to)\",\n \"def render_sheet_to_file(self, file_name, sheet, **keywords):\\n raise NotImplementedError(\\\"We are not writing to file\\\")\",\n \"def write(self, block_no, value):\\n with open(self.file_path, 'r+') as f:\\n f.seek(block_no * config.block_size)\\n f.write(value)\",\n \"def write(self, filename, data):\\n raise NotImplementedError\",\n \"def write(self, filename, **kwargs):\\n self.to_table().write(filename, format='fits', **kwargs)\",\n \"def save(self, fname) -> None:\\n\\n ss = self.to_spreadsheet()\\n ss.save(fname)\",\n \"def write(self, filename):\\n f = open(filename, 'w')\\n f.write(str(self.m) + \\\"\\\\n\\\")\\n f.write(str(self.n) + \\\"\\\\n\\\")\\n for i in self.values:\\n for j in i:\\n f.write(str(j)+\\\"\\\\n\\\")\\n f.closed\",\n \"def save(self,outPath=None):\\n if (not self.canSave or self.skipObjRecords): raise StateError(_(\\\"Insufficient data to write file.\\\"))\\n if not outPath:\\n fileInfo = self.fileInfo\\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\\n out = file(outPath,'wb')\\n #--Tes3 Record\\n self.tes3.changed = 1\\n self.tes3.hedr.changed = 1\\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\\n self.tes3.getSize()\\n self.tes3.dump(out)\\n #--Size Cell Records\\n cntRecords = 0\\n progress = self.progress\\n progress.setMax(len(self.cells))\\n progress(0.0,'Saving '+self.fileInfo.name)\\n for record in self.cells:\\n record.getSize()\\n #--Progress\\n cntRecords += 1\\n progress(cntRecords)\\n #--Other Records\\n for record in self.records:\\n record.getSize() #--Should already be done, but just in case.\\n record.dump(out)\\n out.close()\",\n \"def write(self, filename=None):\\n if filename == None:\\n filename = self.ofilename\\n\\n ofile = open(filename, 'w')\\n\\n ofile.write('# Susceptibility: %E d(susc): %E Coercivity: %E d(coer): %E\\\\n' % (self.susceptibility_mean, self.susceptibility_std, self.coercivity_mean, self.coercivity_std) )\\n ofile.write('# H[] M[] Mfit[]\\\\n')\\n\\n #for i in range(len(self.h)):\\n # ofile.write(\\\" %12.10f %12.10f %12.10f\\\\n\\\" % ( self.h[i], self.m[i], self.m_fit[i] ) )\\n\\n ofile.close()\",\n \"def write_to(self, fname, **kwargs):\\n data = self.to_Table()\\n data.write(fname, **kwargs)\",\n \"def write(filename):\\n print(uc.write(filename))\",\n \"def writeGP(loc, fname, data, header, ncol=6):\\n size = len(data)\\n nrow = int(size / ncol)\\n size_last_row = size % ncol\\n\\n lines = \\\"\\\"\\n for line in np.reshape(range(nrow * ncol), (nrow, ncol)):\\n for val in line:\\n lines += \\\"{:^20.6e}\\\".format(data[val]) + 3 * \\\" \\\"\\n lines = lines.rstrip(3 * \\\" \\\") + \\\"\\\\n\\\"\\n\\n if size_last_row:\\n for i in range(1, size_last_row + 1):\\n lines += \\\"{:^20.6e}\\\".format(data[-i]) + 3 * \\\" \\\"\\n lines = lines.rstrip(3 * \\\" \\\")\\n\\n with open(\\\"/\\\".join([loc, fname]), \\\"w\\\") as f:\\n f.writelines(header)\\n f.writelines(lines)\\n return\",\n \"def save_data(data, filename, path=\\\"\\\", cell=None):\\n if cell is not None:\\n with open((os.getcwd() + \\\"/results/{0}_{1}.json\\\").format(filename, cell), 'w') as f:\\n json.dump(data, f, sort_keys=True, indent=4, separators=(',', ': '))\\n else:\\n with open((os.getcwd() + \\\"/results/{0}.json\\\").format(filename), 'w') as f:\\n json.dump(data, f, sort_keys=True, indent=4, separators=(',', ': '))\",\n \"def _write(self):\\n # Reload\\n with portalocker.Lock(self.filename, 'w') as fh:\\n self.data.to_csv(fh, index=False)\\n fh.flush()\\n os.fsync(fh.fileno())\",\n \"def write(cls, file, data):\\n file.write(data)\",\n \"def write_file(self):\\n rl_df, lift_df = self.create_df()\\n\\n number = re.findall('\\\\d+', self.url)[0]\\n\\n if self.write is True:\\n with open('house_{}.csv'.format(number), 'w',\\n encoding='utf-8-sig') as file:\\n rl_df.to_csv(file, sep=';')\\n with open('house_lifts_{}.csv'.format(number), 'w',\\n encoding='utf-8-sig') as file2:\\n lift_df.to_csv(file2, sep=';')\",\n \"def save_to_file(grid, filepath):\\n outfile = codecs.open(filepath, mode='w+', encoding='utf-8')\\n outfile.writelines([((''.join(row)) + u'\\\\n') for row in grid])\",\n \"def write(self, cw, message):\\n if cw in self.location:\\n fn = self.location[str(cw)]\\n try:\\n swf = open(fn, \\\"w\\\")\\n except Exception:\\n logmsg.update(\\\"Error writing to file \\\" + fn + \\\"!\\\", 'E')\\n else:\\n swf.write(str(message))\\n swf.close()\\n else:\\n logmsg.update(\\\"Wrong target [\\\" + str(cw) + \\\"] for saving file!\\\", 'E')\",\n \"def test_write_data(workbook):\\n workbook.write_data(\\\"example data\\\")\\n assert workbook.get_cell(workbook.get_last_row(), 1) == \\\"example data\\\"\",\n \"def write_to_binary_file(self, filename):\\n\\n self.octree.writeBinary(str.encode(filename))\",\n \"def file_write(stuff, file_path):\\n with open(file_path, \\\"wt\\\") as fo:\\n fo.write(stuff)\",\n \"def write_file(self):\\r\\n # -open file for writing\\r\\n f_fbob = open(self.fn_path, 'w')\\r\\n\\r\\n # -write header\\r\\n f_fbob.write('%s\\\\n' % (self.heading))\\r\\n\\r\\n # -write sections 1 & 2 : NOTE- what about NOPRINT?\\r\\n f_fbob.write('%10i%10i%10i%10i\\\\n' % (self.nqfb, self.nqcfb,\\r\\n self.nqtfb, self.iufbobsv))\\r\\n f_fbob.write('%10e\\\\n' % (self.tomultfb)) # check format\\r\\n\\r\\n # -write sections 3-5 looping through observations groups\\r\\n c = 0\\r\\n for i in range(self.nqfb):\\r\\n # while (i < self.nqfb):\\r\\n # write section 3\\r\\n f_fbob.write('{:10d}{:10d}\\\\n'.format(self.nqobfb[i],\\r\\n self.nqclfb[i]))\\r\\n\\r\\n # Loop through observation times for the groups\\r\\n for j in range(self.nqobfb[i]):\\r\\n # -write section 4\\r\\n f_fbob.write(\\r\\n '{}{:10d}{:10.4g}{}{:10.4g}\\\\n'.format(self.obsnam[c],\\r\\n self.irefsp[c],\\r\\n self.toffset[c], ' ',\\r\\n self.flwobs[c]))\\r\\n c += 1 # index variable\\r\\n\\r\\n # -write section 5 - NOTE- need to adjust factor for muliple obs same cell\\r\\n for j in range(abs(self.nqclfb[i])):\\r\\n if self.nqclfb[\\r\\n i] < 0: # set factor to 1.0 for all cells in group\\r\\n self.factor[i, :] = 1.0\\r\\n f_fbob.write('{:10d}{:10d}{:10d}{}{:10f}\\\\n'\\r\\n .format(self.layer[i, j], (self.row[i, j]),\\r\\n self.column[i, j],\\r\\n ' ', self.factor[\\r\\n i, j])) # note- is 10f good enough here?\\r\\n\\r\\n f_fbob.close()\\r\\n #\\r\\n # swm: BEGIN hack for writing standard file\\r\\n sfname = self.fn_path # swm:hack\\r\\n sfname += '_ins' # swm: hack\\r\\n # write header\\r\\n f_ins = open(sfname, 'w') # swm: hack for standard file\\r\\n f_ins.write('jif @\\\\n') # swm: hack for standard file\\r\\n f_ins.write('StandardFile 0 1 %s\\\\n' % (\\r\\n self.nqtfb)) # swm: hack for standard file\\r\\n for i in range(0, self.nqtfb):\\r\\n f_ins.write(\\r\\n '{}\\\\n'.format(self.obsnam[i])) # swm: hack for standard file\\r\\n\\r\\n f_ins.close()\\r\\n # swm: END hack for writing standard file\\r\\n\\r\\n return\",\n \"def write_to_file(board, output_file = \\\"solution.sud\\\"):\\n with open(output_file, \\\"w\\\") as f:\\n for i in range(n):\\n if i and i%3==0:\\n f.write(\\\"------+-------+------\\\\n\\\")\\n for j in range(n): \\n if j and j%3==0:\\n f.write(\\\"| \\\")\\n if len(board[i][j]) == 1:\\n f.write(str(board[i][j][0]) + \\\" \\\")\\n else:\\n f.write(\\\". \\\")\\n elif j==8:\\n if len(board[i][j]) == 1:\\n f.write(str(board[i][j][0]) + \\\"\\\\n\\\")\\n else:\\n f.write(\\\".\\\\n\\\")\\n else:\\n if len(board[i][j]) == 1:\\n f.write(str(board[i][j][0]) + \\\" \\\")\\n else:\\n f.write(\\\". \\\")\\n return 0\",\n \"def write_to_file(self, filename):\\n self.octree.write(str.encode(filename))\\n print(\\\"Save octomap to \\\"+filename)\",\n \"def write (self, file):\\n\\t\\tfile.write (self.pack ())\",\n \"def _save_chromosome_at_index(self, index, file_name):\\n how_to_open = 'w' if index == 0 else 'a'\\n with open(file_name, how_to_open) as out_file:\\n for category in self.population[index].get_genes():\\n out_file.write(''.join(category) + '\\\\t')\\n out_file.write(\\n '\\\\n{}\\\\n'.format(self.population[index].get_fitness())\\n )\",\n \"def save_EGRID( self , filename , output_unit = EclUnitTypeEnum.ERT_ECL_METRIC_UNITS):\\n self._fwrite_EGRID2( filename, output_unit )\",\n \"def write_table(self, G, myfile):\\r\\n self.node_table(G, myfile)\\r\\n self.edge_table(G, myfile)\\r\\n return myfile\",\n \"def write_binary_cells(self, binary_cells):\\n for bc in binary_cells:\\n self._outfile.write(bc)\\n return self\",\n \"def exportPlayground(self, filepath):\\n cellPositions = \\\"\\\"\\n for cell in self.cells:\\n if(cell.dead == False):\\n cellPositions += str(cell.x) + \\\" \\\" + str(cell.y) + \\\"\\\\n\\\"\\n \\n fileWrite = open(filepath, \\\"w\\\")\\n fileWrite.write(cellPositions)\\n fileWrite.close()\",\n \"def saveOnFile(self, path, data):\\n with open(path, \\\"w\\\") as f:\\n f.write(data)\",\n \"def write(self, filename):\\n with open(filename, \\\"w\\\") as f:\\n f.write(self.get_string())\",\n \"def write(self, filename):\\n with open(filename, \\\"w\\\") as f:\\n f.write(self.get_string())\",\n \"def __writeElement(fd, elm):\\n\\n print(\\n \\\" <td>\\\",\\n \\\" <h4>\\\" + elm[\\\"name\\\"] + \\\"</h4>\\\",\\n \\\" <ul>\\\",\\n \\\" <li>\\\" + str(elm[\\\"number\\\"]) + \\\"</li>\\\",\\n \\\" <li>\\\" + elm[\\\"small\\\"] + \\\"</li>\\\",\\n \\\" <li>\\\" + str(elm[\\\"molar\\\"]) + \\\"</li>\\\",\\n \\\" </ul>\\\",\\n \\\" </td>\\\",\\n sep=\\\"\\\\n\\\",\\n file=fd\\n )\",\n \"def write(self, quit_app=False):\\n self._app[\\\"statusbar\\\"].message(\\\"Saving...\\\", \\\"info\\\")\\n # Manipulations include transformations implicitly\\n if self._app[\\\"manipulate\\\"].is_visible():\\n self._app[\\\"manipulate\\\"].finish(True)\\n self._changes.clear()\\n # Only apply any transformations\\n else:\\n self._thread_for_apply()\\n # Quit or inform\\n if quit_app:\\n self._app.quit_wrapper()\\n else:\\n self._app[\\\"statusbar\\\"].message(\\\"Changes written to disk\\\", \\\"info\\\")\",\n \"def write():\\n pass\",\n \"def write(self, arg, **kwargs):\\r\\n if hasattr(arg, 'seek'):\\r\\n self._tofile(arg, **kwargs)\\r\\n else:\\r\\n with open(arg, 'wb') as fid:\\r\\n self._tofile(fid, **kwargs)\",\n \"def write(self, row):\\n bytes = struct.pack(self.pack_format, *row)\\n self.f.write(bytes)\",\n \"def write_elongation(elongation, file_name, style=None):\\n style = file_name.split('.')[-1] if style is None else style\\n\\n if style == 'csv':\\n write_csv(elongation, file_name)\\n elif style == 'prn':\\n raise NotImplementedError()\\n else:\\n raise NotImplementedError()\",\n \"def write(self, val, prefix, args=()):\\n file_path = self.path(prefix, args)\\n val_str = self.writer_(val)\\n autofile.write_file(file_path, val_str)\",\n \"def write(self, filename, *args, **kwargs):\\n self.to_fits().writeto(filename, *args, **kwargs)\",\n \"def write(self, path):\\n # if file doesn't already exist, write column names in a header\\n if not os.path.exists(path):\\n with open(path, 'a+') as f:\\n f.write('# {}# time,status,dphi,umolar,mbar,airSat,tempSample,tempCase,signalIntensity,ambientLight,pressure,humidity,resistorTemp,percentO2\\\\n'.format(self.label))\\n # generate out_str\\n if isinstance(self.last_read[0], list):\\n out_str = ''\\n for r in self.last_read:\\n out_str += fmt(r, 1, ',') + '\\\\n'\\n else:\\n out_str = fmt(self.last_read, 1, ',') + '\\\\n'\\n # write and save data\\n self.write_str = out_str\\n with open(path, 'a+') as f:\\n f.write(out_str)\\n return\",\n \"def writeto(self, filename, overwrite=True, **kwargs):\\n from astropy.io import fits\\n return fits.writeto( filename, self.data, header=self.header,\\n overwrite=overwrite, **kwargs)\",\n \"def write(self, filename, filepath, overwrite=True):\\n super().write(filename, filepath, overwrite)\\n try:\\n with open(filename, 'w') as output:\\n output.write(str(self._formatter))\\n except IOError as e:\\n print(type(e))\\n print(e.args)\\n print(e)\",\n \"def write_binary(self, path):\\n return\",\n \"def FileWrite(offset, buf):\\r\\n return _hiew.HiewGate_FileWrite(offset, buf)\",\n \"def _write(i):\\n try:\\n spreadsheet = _get_spreadsheet(i)\\n except IOError:\\n msg = '{} parties spreadsheet not found'.format(i.canonical_name)\\n logger.log_warning(msg)\\n else:\\n content = _get_content(i, spreadsheet)\\n if content:\\n _write_content(i, content)\",\n \"def write_to_file(filepath, data):\\n\\n with open(filepath, 'w') as f:\\n f.write(str(data))\",\n \"def write(self):\\n\\t\\traise NotImplementedError('%s: No write function implemented!' % self.name)\",\n \"def writeFile(filename):\\n\\n with open(filename, \\\"w\\\") as f:\\n Write.__writeHeader(f)\\n\\n Write.__openRow(f)\\n i = 0\\n for elm in Parse.data:\\n while i != elm[\\\"position\\\"]:\\n Write.__writeEmptyElement(f)\\n i += 1\\n\\n Write.__writeElement(f, elm)\\n i += 1\\n\\n if elm[\\\"position\\\"] == 17:\\n i = 0\\n Write.__closeRow(f)\\n if elm[\\\"number\\\"] != 118:\\n Write.__openRow(f)\\n\\n Write.__writeFooter(f)\",\n \"def save_to(self, f: BinaryIO):\\n raise NotImplementedError\",\n \"def write_to_file(filename, content):\\n with open(filename, 'w') as f:\\n f.write(content)\",\n \"def output_1cell(self, filename):\\n\\n date_concat = \\\"{0} to {1}\\\".format(self.startDate, self.endDate)\\n if active_restaurant_loop:\\n column_name = [\\\"range\\\", \\\"start_date\\\",\\n \\\"end_date\\\", \\\"location_id\\\", \\\"content\\\"]\\n data = [date_concat, self.startDate, self.endDate, str(\\n self.payload[\\\"locationGroupID\\\"]), \\\"{0}\\\".format(self.content)]\\n data_out = [column_name, data]\\n else:\\n column_name = [\\\"range\\\", \\\"start_date\\\", \\\"end_date\\\", \\\"content\\\"]\\n data = [date_concat, self.startDate,\\n self.endDate, \\\"{0}\\\".format(self.content)]\\n data_out = [column_name, data]\\n\\n # If active restaurant loop is true\\n if not os.path.isfile(filename):\\n with open(filename, \\\"w\\\") as f:\\n writer = csv.writer(f)\\n #writer.writerow([\\\"range\\\", \\\"start_date\\\", \\\"end_date\\\", \\\"content\\\"])\\n #writer.writerow([date_concat, start_date, end_date, \\\"{0}\\\".format(self.content)])\\n writer.writerows(data_out)\\n # f.write([\\\"content\\\"])\\n # f.write([\\\"{0}\\\"].format(self.content))\\n f.close()\\n else:\\n with open(filename, \\\"a\\\") as f:\\n writer = csv.writer(f)\\n writer.writerows([data])\\n f.close()\\n\\n logging.info(\\\"Outputting... \\\")\\n self.produce_manifest(filename)\",\n \"def write(self, data_to_write):\\n self.single_file.write(data_to_write)\\n self.single_file.flush()\",\n \"def _write(self, data):\\n self._writer.write(data)\",\n \"def write_shapefile(self, filename='grid.shp', epsg=None, prj=None):\\n from ..export.shapefile_utils import write_grid_shapefile2\\n if epsg is None and prj is None:\\n epsg = self.epsg\\n write_grid_shapefile2(filename, self, array_dict={}, nan_val=-1.0e9,\\n epsg=epsg, prj=prj)\",\n \"def write_field(self,filename,field,griddescfile=None,fieldname=None):\\n\\n pass\",\n \"def set_cell(self, cell, val):\\n a = b = 0\\n try:\\n a, b = self.__ret_cell(cell)\\n self._grid[a][b] = val\\n except IndexError as e:\\n self.perror(\\\"Error: '%s'.\\\" % e, cell, a, b, 5)\\n self.perror(\\\"Error.\\\", cell, a, b, 5)\\n sys.exit()\",\n \"def write(self, outfile):\\n outfile.write(\\n '\\\\t'.join(\\n [\\n str(i) for i in [\\n self.chrom, self.start, self.end, self.name,\\n self.count, self.fold_change, self.log10p\\n ]\\n ]\\n )\\n )\\n outfile.write('\\\\n')\",\n \"def writeToFile(self):\\n self.dto.writeToCsv()\\n print(\\\"File written.\\\")\",\n \"def write_ptm_gridfile(self,fn):\\n vertex_hdr = \\\" Vertex Data: vertex_number, x, y\\\"\\n poly_hdr = \\\" Polygon Data: polygon_number, number_of_sides,center_x, center_y, center_depth, side_indices(number_of_sides), marker(0=internal,1=open boundary)\\\"\\n side_hdr = \\\" Side Data: side_number, side_depth, node_indices(2), cell_indices(2), marker(0=internal,1=external,2=flow boundary,3=open boundary)\\\"\\n\\n with open(fn,'wt') as fp:\\n # write header counts\\n fp.write(\\\" Number of Vertices\\\\n\\\")\\n fp.write(\\\" %20d\\\\n\\\"%self.Nnodes())\\n fp.write(\\\" Number of Polygons\\\\n\\\")\\n fp.write(\\\" %20d\\\\n\\\"%self.Ncells())\\n fp.write(\\\" Number of Sides\\\\n\\\")\\n fp.write(\\\" %20d\\\\n\\\"%self.Nedges())\\n fp.write(\\\" NODATA (land) value\\\\n\\\")\\n fp.write(\\\" -9999.000000000\\\\n\\\")\\n\\n # write vertex info\\n fp.write(vertex_hdr+\\\"\\\\n\\\")\\n for v in range(self.Nnodes()):\\n fp.write(\\\" %10d %16.7f %16.7f\\\\n\\\"%(v+1,\\n self.nodes['x'][v,0],\\n self.nodes['x'][v,1]))\\n\\n # write polygon info\\n fp.write(poly_hdr+\\\"\\\\n\\\")\\n cell_write_str1 = \\\" %10d %10d %16.7f %16.7f %16.7f \\\"\\n cell_depths = self.cell_depths()\\n for e in range(self.Ncells()):\\n edges = self.cells['edges'][e,:]\\n edges[edges<0] = -1\\n edge_str = \\\" \\\".join( [\\\"%10d\\\"%(s+1) for s in edges] )\\n edge_str = edge_str+\\\" %10d\\\\n\\\"%(self.cells['mark'][e])\\n nsides = sum(edges>=0)\\n fp.write(cell_write_str1%(e+1,\\n nsides,\\n self.cells['_center'][e,0],\\n self.cells['_center'][e,1],\\n cell_depths[e]))\\n fp.write(edge_str)\\n \\n # write side info\\n fp.write(side_hdr+\\\"\\\\n\\\")\\n edge_depths = self.edge_depths()\\n edge_write_str = \\\" %10d %16.7f %10d %10d %10d %10d %10d\\\\n\\\"\\n for s in range(self.Nedges()):\\n edges = self.edges['cells'][s,:]\\n edges[edges<0] = -1 \\n nodes = self.edges['nodes'][s,:]\\n nodes[nodes<0] = -1\\n fp.write(edge_write_str%(s+1,\\n edge_depths[s],\\n nodes[0]+1,\\n nodes[1]+1,\\n edges[0]+1,\\n edges[1]+1,\\n self.edges['mark'][s]))\",\n \"def writeRowToFile(filename, row):\\n try:\\n with open(filename,'a',newline='') as f:\\n row_writer = csv.writer(f)\\n row_writer.writerow(row)\\n except:\\n with open('error_log.csv','a', newline='') as error_f:\\n print('Error writing to file')\\n row_writer = csv.writer(error_f)\\n row_writer.writerow(row)\",\n \"def __write_place(self, handle, nbr):\\n try:\\n place = self.database.get_place_from_handle(handle)\\n self.__write_row(nbr, handle, place)\\n except:\\n place = \\\"NOT FOUND\\\"\\n self.__write_row(nbr, handle, place)\",\n \"def write(self, data):\\n return self._write(self.wfile, data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7893535","0.7167007","0.64020705","0.6233088","0.6106569","0.60965765","0.60965765","0.605748","0.59968483","0.59903365","0.5989713","0.5946001","0.59330434","0.58675724","0.5825177","0.58209854","0.58193207","0.57958156","0.5771627","0.5768062","0.57342947","0.5719415","0.57104045","0.5702582","0.56932694","0.5671611","0.5655174","0.5655174","0.5650916","0.56448686","0.56017834","0.5593185","0.55911547","0.5589793","0.55860883","0.55841297","0.55707705","0.5568231","0.5559449","0.5556521","0.5544158","0.5533215","0.5522413","0.55120766","0.5511709","0.55063766","0.55051273","0.54995084","0.5493206","0.5492481","0.5476532","0.54552287","0.54483885","0.54470885","0.54392445","0.5435129","0.54157907","0.5388401","0.53859043","0.53830403","0.53729725","0.5368014","0.5346913","0.53437424","0.5335231","0.53319067","0.53296596","0.5328227","0.5328227","0.5320997","0.5310984","0.53067935","0.53052545","0.5300622","0.5298288","0.52936095","0.52907753","0.5278189","0.5270433","0.5268977","0.52675474","0.52582103","0.5254787","0.5254197","0.5242377","0.52415985","0.52366155","0.5235833","0.52345884","0.5231314","0.5230818","0.5230479","0.5230372","0.522202","0.52189094","0.5217825","0.52168864","0.5216147","0.52160496","0.52143323"],"string":"[\n \"0.7893535\",\n \"0.7167007\",\n \"0.64020705\",\n \"0.6233088\",\n \"0.6106569\",\n \"0.60965765\",\n \"0.60965765\",\n \"0.605748\",\n \"0.59968483\",\n \"0.59903365\",\n \"0.5989713\",\n \"0.5946001\",\n \"0.59330434\",\n \"0.58675724\",\n \"0.5825177\",\n \"0.58209854\",\n \"0.58193207\",\n \"0.57958156\",\n \"0.5771627\",\n \"0.5768062\",\n \"0.57342947\",\n \"0.5719415\",\n \"0.57104045\",\n \"0.5702582\",\n \"0.56932694\",\n \"0.5671611\",\n \"0.5655174\",\n \"0.5655174\",\n \"0.5650916\",\n \"0.56448686\",\n \"0.56017834\",\n \"0.5593185\",\n \"0.55911547\",\n \"0.5589793\",\n \"0.55860883\",\n \"0.55841297\",\n \"0.55707705\",\n \"0.5568231\",\n \"0.5559449\",\n \"0.5556521\",\n \"0.5544158\",\n \"0.5533215\",\n \"0.5522413\",\n \"0.55120766\",\n \"0.5511709\",\n \"0.55063766\",\n \"0.55051273\",\n \"0.54995084\",\n \"0.5493206\",\n \"0.5492481\",\n \"0.5476532\",\n \"0.54552287\",\n \"0.54483885\",\n \"0.54470885\",\n \"0.54392445\",\n \"0.5435129\",\n \"0.54157907\",\n \"0.5388401\",\n \"0.53859043\",\n \"0.53830403\",\n \"0.53729725\",\n \"0.5368014\",\n \"0.5346913\",\n \"0.53437424\",\n \"0.5335231\",\n \"0.53319067\",\n \"0.53296596\",\n \"0.5328227\",\n \"0.5328227\",\n \"0.5320997\",\n \"0.5310984\",\n \"0.53067935\",\n \"0.53052545\",\n \"0.5300622\",\n \"0.5298288\",\n \"0.52936095\",\n \"0.52907753\",\n \"0.5278189\",\n \"0.5270433\",\n \"0.5268977\",\n \"0.52675474\",\n \"0.52582103\",\n \"0.5254787\",\n \"0.5254197\",\n \"0.5242377\",\n \"0.52415985\",\n \"0.52366155\",\n \"0.5235833\",\n \"0.52345884\",\n \"0.5231314\",\n \"0.5230818\",\n \"0.5230479\",\n \"0.5230372\",\n \"0.522202\",\n \"0.52189094\",\n \"0.5217825\",\n \"0.52168864\",\n \"0.5216147\",\n \"0.52160496\",\n \"0.52143323\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74768186"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":16497,"cells":{"query":{"kind":"string","value":"Write the specified binary cells to the file."},"document":{"kind":"string","value":"def write_binary_cells(self, binary_cells):\n for bc in binary_cells:\n self._outfile.write(bc)\n return self"},"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 write_binary(self, path):\n return","def write_df_to_binary(file_name_mask, df):\n write_matrix_to_binary(file_name_mask + '-value.bin', df.values)\n with open(file_name_mask + '-name.txt', 'w') as f:\n f.write(\"\\t\".join(df.index))\n f.write(\"\\n\")\n f.write(\"\\t\".join(df.columns))\n f.write(\"\\n\")","def write_gds(self, outfile, cells=None, timestamp=None, binary_cells=None):\n close = True\n if hasattr(outfile, \"__fspath__\"):\n outfile = open(outfile.__fspath__(), \"wb\")\n elif isinstance(outfile, (basestring, Path)):\n outfile = open(outfile, \"wb\")\n else:\n close = False\n now = datetime.datetime.today() if timestamp is None else timestamp\n name = self.name if len(self.name) % 2 == 0 else (self.name + \"\\0\")\n outfile.write(\n struct.pack(\n \">5H12h2H\",\n 6,\n 0x0002,\n 0x0258,\n 28,\n 0x0102,\n now.year,\n now.month,\n now.day,\n now.hour,\n now.minute,\n now.second,\n now.year,\n now.month,\n now.day,\n now.hour,\n now.minute,\n now.second,\n 4 + len(name),\n 0x0206,\n )\n + name.encode(\"ascii\")\n + struct.pack(\">2H\", 20, 0x0305)\n + _eight_byte_real(self.precision / self.unit)\n + _eight_byte_real(self.precision)\n )\n if cells is None:\n cells = self.cells.values()\n else:\n cells = [self.cells.get(c, c) for c in cells]\n if len(cells) == 0:\n warnings.warn(\"[GDSPY] Creating a GDSII file without any cells.\")\n for cell in cells:\n cell.to_gds(outfile, self.unit / self.precision, timestamp=timestamp)\n if binary_cells is not None:\n for bc in binary_cells:\n outfile.write(bc)\n outfile.write(struct.pack(\">2H\", 4, 0x0400))\n if close:\n outfile.close()","def write_to_binary_file(self, filename):\n\n self.octree.writeBinary(str.encode(filename))","def bin_writer(fpath, fname, data):\n path = fpath + fname + '.dat'\n with open(path, 'ab') as file:\n for row in data:\n file.write(row.encode('utf-8'))\n return None","def write_bin(file, binary, buffer=None, append=True):\n\n # Get current stream, default or not.\n stream = cp.cuda.get_current_stream()\n\n if buffer is None:\n buffer = cp.asnumpy(binary)\n else:\n binary.get(out=buffer)\n\n if append is True:\n mode = \"ab\"\n else:\n mode = \"wb\"\n\n with open(file, mode) as f:\n stream.synchronize()\n buffer.tofile(f)","def write_cell(self, cell):\n self._outfile.write(cell.to_gds(self._res))\n return self","def write_subactors_file_binary(filename, G, nodelist, profile, colnames):\n assert(len(nodelist) == G.GetNodes())\n assert(len(profile) >= G.GetNodes())\n binattrs = ['gender', 'public']\n # rename gender to male for binary attribute\n binattr_names = ['male' if x == 'gender' else x for x in binattrs] \n with open(filename, 'w') as f:\n f.write(' '.join(binattr_names) + '\\n')\n for i in nodelist:\n for attr in binattrs:\n val = profile[i][colnames[attr]]\n val = val if val in ['0','1'] else 'NA'\n f.write(val)\n if attr == binattrs[-1]:\n f.write('\\n')\n else:\n f.write(' ' )","def write_file(self):\n print 'Writing '+self.name+' binary...'\n if self.vals is not None:\n if len(self.vals) == self.size:\n stream = self.pack_mem()\n with open(self.name+'.bin','wb') as f:\n f.write(stream)\n print 'File written: '+self.name+'.bin'\n else:\n print 'Error: input array for '+self.name+'is not the right '+\\\n 'size (should be '+str(self.size)+'). Skipping.'\n else:\n print 'No array provided, skipping.'","def tabser(filename, body, data):\n # XXX checksums ignored\n head = Struct(\"!BiHBxxxB\")\n body = Struct(body)\n # foot = Struct(\"!4s\")\n\n buffer = bytearray([0] * (2 ** 16))\n head.pack_into(buffer, 0, 0, int(time()), len(data), body.size, 0),\n offset = head.size\n for row in data:\n body.pack_into(buffer, offset, *row, 0)\n offset += body.size\n else:\n print(\"write %d rows\" % len(data))\n # offset = 2 ** 16 - foot.size\n # foot.pack_into(buffer, offset, bytes([0, 0, 0, 0]))\n with open(filename, \"wb\") as f:\n f.write(buffer)","def write_gds(self, outfile, cells=None, timestamp=None):\n if isinstance(outfile, basestring):\n outfile = open(outfile, 'wb')\n close = True\n else:\n close = False\n now = datetime.datetime.today() if timestamp is None else timestamp\n name = self.name if len(self.name) % 2 == 0 else (self.name + '\\0')\n outfile.write(\n struct.pack('>19h', 6, 0x0002, 0x0258, 28, 0x0102, now.year,\n now.month, now.day, now.hour, now.minute, now.second,\n now.year, now.month, now.day, now.hour, now.minute,\n now.second, 4 + len(name), 0x0206) +\n name.encode('ascii') + struct.pack('>2h', 20, 0x0305) +\n _eight_byte_real(self.precision / self.unit) +\n _eight_byte_real(self.precision))\n if cells is None:\n cells = self.cell_dict.values()\n else:\n cells = [self.cell_dict.get(c, c) for c in cells]\n for cell in cells:\n outfile.write(cell.to_gds(self.unit / self.precision))\n outfile.write(struct.pack('>2h', 4, 0x0400))\n if close:\n outfile.close()","def save_bin(data, file_path):\n np.save(file_path, data)","def _save_binary(file_name, data):\n with open(file_name, \"wb\") as f:\n cp.dump(data, f)","def write_matrix_to_binary(file_name, val):\n with open(file_name, 'wb') as file:\n nrow = val.shape[0]\n ncol = val.shape[1]\n file.write(int32_to_bytes(nrow) + int32_to_bytes(ncol) + val.astype(float).tobytes(order='C'))","def write_cells_shp(self,shpname,extra_fields=[],overwrite=True):\n # assemble a numpy struct array with all of the info \n # seems that having an object references in there is unstable,\n # so pass geometries in a list separately.\n base_dtype =[('poly_id1',np.int32),\n ('area',np.float64),\n ('volume',np.float64),\n ('depth_mean',np.float64)]\n\n try:\n cell_depths_max = self.cell_depths_max()\n extra_fields.append( ('depth_max',np.float64, lambda i: cell_depths_max[i]) )\n except:\n pass\n\n for efi in range(len(extra_fields)):\n fname,fdata=extra_fields[efi]\n base_dtype.append( (fname,fdata.dtype) )\n\n cell_data = np.zeros(self.Ncells(), dtype=base_dtype)\n\n for efi in range(len(extra_fields)):\n fname,fdata=extra_fields[efi]\n cell_data[fname]=fdata\n\n self.update_cell_edges()\n\n cell_geoms = [None]*self.Ncells()\n \n cell_data['depth_mean'] = self.cell_depths()\n cell_data['area']=self.cells_area()\n cell_data['volume']=cell_data['depth_mean']*cell_data['area']\n cell_data['poly_id1'] = 1+np.arange(self.Ncells())\n\n for poly_id in range(self.Ncells()):\n if poly_id % 500 == 0:\n print( \"%0.2g%%\"%(100.*poly_id/self.Ncells()) )\n\n # older code put this together manually.\n cell_geoms[poly_id]=self.cell_polygon(poly_id)\n\n print( cell_data.dtype )\n wkb2shp.wkb2shp(shpname,input_wkbs=cell_geoms,fields=cell_data,\n overwrite=overwrite)","def save_bin(words,data,fname):\n\n out=open(fname,\"wb\")\n\n rows,dims=data.shape\n out.write(\"{} {}\\n\".format(rows,dims).encode(\"utf-8\"))\n counter=0\n\n for i,w in enumerate(words):\n out.write(w.encode(\"utf-8\"))\n out.write(\" \".encode(\"utf-8\"))\n out.write(struct.pack(\"{}f\".format(dims),*data[i,:]))\n counter+=1\n \n out.close()\n print(\"Model saved to\",fname,file=sys.stderr)","def binary_write(iring, file_ext='out', *args, **kwargs):\n return BinaryFileWriteBlock(iring, file_ext, *args, **kwargs)","def save_fits(data, fname):\n\tcols = fits.ColDefs(np.copy(data)) # This is somehow necessary.\n\ttbhdu = fits.BinTableHDU.from_columns(cols)\n\ttbhdu.writeto(fname, clobber=True)\n\t\n\treturn","def write_binary(self, data, ensure=False):\n if ensure:\n self.dirpath().ensure(dir=1)\n with self.open(\"wb\") as f:\n f.write(data)","def writeCell(hoja, fila, columna, dato, formato=''):\r\n if formato:\r\n hoja.write(fila, columna, dato, formato)\r\n else:\r\n hoja.write(fila, columna, dato)","def save_to(self, f: BinaryIO):\n raise NotImplementedError","def write(filename, data, extname=None, extver=None, header=None,\n clobber=False, ignore_empty=False, units=None, table_type='binary',\n names=None, write_bitcols=False, compress=None, tile_dims=None,\n **keys):\n if keys:\n import warnings\n warnings.warn(\n \"The keyword arguments '%s' are being ignored! This warning \"\n \"will be an error in a future version of `fitsio`!\" % keys,\n DeprecationWarning, stacklevel=2)\n\n kwargs = {\n 'clobber': clobber,\n 'ignore_empty': ignore_empty\n }\n with FITS(filename, 'rw', **kwargs) as fits:\n fits.write(data,\n table_type=table_type,\n units=units,\n extname=extname,\n extver=extver,\n compress=compress,\n header=header,\n names=names,\n write_bitcols=write_bitcols,\n tile_dims=tile_dims)","def write_file(self):\r\n # -open file for writing\r\n f_fbob = open(self.fn_path, 'w')\r\n\r\n # -write header\r\n f_fbob.write('%s\\n' % (self.heading))\r\n\r\n # -write sections 1 & 2 : NOTE- what about NOPRINT?\r\n f_fbob.write('%10i%10i%10i%10i\\n' % (self.nqfb, self.nqcfb,\r\n self.nqtfb, self.iufbobsv))\r\n f_fbob.write('%10e\\n' % (self.tomultfb)) # check format\r\n\r\n # -write sections 3-5 looping through observations groups\r\n c = 0\r\n for i in range(self.nqfb):\r\n # while (i < self.nqfb):\r\n # write section 3\r\n f_fbob.write('{:10d}{:10d}\\n'.format(self.nqobfb[i],\r\n self.nqclfb[i]))\r\n\r\n # Loop through observation times for the groups\r\n for j in range(self.nqobfb[i]):\r\n # -write section 4\r\n f_fbob.write(\r\n '{}{:10d}{:10.4g}{}{:10.4g}\\n'.format(self.obsnam[c],\r\n self.irefsp[c],\r\n self.toffset[c], ' ',\r\n self.flwobs[c]))\r\n c += 1 # index variable\r\n\r\n # -write section 5 - NOTE- need to adjust factor for muliple obs same cell\r\n for j in range(abs(self.nqclfb[i])):\r\n if self.nqclfb[\r\n i] < 0: # set factor to 1.0 for all cells in group\r\n self.factor[i, :] = 1.0\r\n f_fbob.write('{:10d}{:10d}{:10d}{}{:10f}\\n'\r\n .format(self.layer[i, j], (self.row[i, j]),\r\n self.column[i, j],\r\n ' ', self.factor[\r\n i, j])) # note- is 10f good enough here?\r\n\r\n f_fbob.close()\r\n #\r\n # swm: BEGIN hack for writing standard file\r\n sfname = self.fn_path # swm:hack\r\n sfname += '_ins' # swm: hack\r\n # write header\r\n f_ins = open(sfname, 'w') # swm: hack for standard file\r\n f_ins.write('jif @\\n') # swm: hack for standard file\r\n f_ins.write('StandardFile 0 1 %s\\n' % (\r\n self.nqtfb)) # swm: hack for standard file\r\n for i in range(0, self.nqtfb):\r\n f_ins.write(\r\n '{}\\n'.format(self.obsnam[i])) # swm: hack for standard file\r\n\r\n f_ins.close()\r\n # swm: END hack for writing standard file\r\n\r\n return","def write(self, fileW):\n fileW.wByte(self.b)\n fileW.wByte(self.g)\n fileW.wByte(self.r)\n fileW.wByte(self.a)","def write(self, data, units=None, extname=None, extver=None,\n compress=None, tile_dims=None, header=None, names=None,\n table_type='binary', write_bitcols=False, **keys):\n\n if keys:\n import warnings\n warnings.warn(\n \"The keyword arguments '%s' are being ignored! This warning \"\n \"will be an error in a future version of `fitsio`!\" % keys,\n DeprecationWarning, stacklevel=2)\n\n isimage = False\n if data is None:\n isimage = True\n elif isinstance(data, numpy.ndarray):\n if data.dtype.fields == None: # noqa - probably should be is None\n isimage = True\n\n if isimage:\n self.write_image(data, extname=extname, extver=extver,\n compress=compress, tile_dims=tile_dims,\n header=header)\n else:\n self.write_table(data, units=units,\n extname=extname, extver=extver, header=header,\n names=names,\n table_type=table_type,\n write_bitcols=write_bitcols)","def writeElems(fil, elems1, eofs=1, nofs=1):\n #pyFormex uses the same convention for hexahedral elements as ABAQUS\n #Gambit uses a different convention\n #function currently only for hexahedral mesh\n elems = elems1.copy()\n elems[:,2] = elems1[:,3]\n elems[:,3] = elems1[:,2]\n\n elems[:,6] = elems1[:,7]\n elems[:,7] = elems1[:,6]\n \n fil.write(' ELEMENTS/CELLS 2.2.30\\n')\n for i,e in enumerate(elems+nofs):\n fil.write('%8d %2d %2d %8d%8d%8d%8d%8d%8d%8d\\n %8d\\n' % ((i+eofs,4,8)+tuple(e)))\n fil.write('ENDOFSECTION\\n')","def write_file(file_name, table):\r\n \r\n savectr=len(table)\r\n try:\r\n with open (file_name, 'wb') as objFile:\r\n pickle.dump(table,objFile) #pickle my 2D list\r\n print ('{} CD(s) saved into {}.\\n'.format(savectr,file_name))\r\n except PermissionError as e:\r\n print('Not enough rights to create/modify ' + file_name + '.') #if unable pickle data due to permission issues\r\n print ()\r\n print (e, e.__doc__, sep='\\n')\r\n print ()\r\n except IOError as e:\r\n print ('I/O error({0}): {1}'.format(e.errno,e.strerror))#if unable to pickle data due to IO errors such as disk space issues\r\n print ()\r\n print (e, e.__doc__, sep='\\n')\r\n print ()\r\n except pickle.PickleError as e:\r\n print ('Unable to write data into ' + file_name + '.') #if unable to pickle 2D list, exception handling for pickling errors\r\n print ()\r\n print (e, e.__doc__, sep='\\n')\r\n print ()","def _saveBinaryData(self, file, with_axis=None):\n if with_axis is not None:\n data = self._data_with_axis(with_axis)\n numpy.save(file, data)\n else:\n numpy.save(file, self.data)","def save(self,outPath=None):\n if (not self.canSave or self.skipObjRecords): raise StateError(_(\"Insufficient data to write file.\"))\n if not outPath:\n fileInfo = self.fileInfo\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\n out = file(outPath,'wb')\n #--Tes3 Record\n self.tes3.changed = 1\n self.tes3.hedr.changed = 1\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\n self.tes3.getSize()\n self.tes3.dump(out)\n #--Size Cell Records\n cntRecords = 0\n progress = self.progress\n progress.setMax(len(self.cells))\n progress(0.0,'Saving '+self.fileInfo.name)\n for record in self.cells:\n record.getSize()\n #--Progress\n cntRecords += 1\n progress(cntRecords)\n #--Other Records\n for record in self.records:\n record.getSize() #--Should already be done, but just in case.\n record.dump(out)\n out.close()","def write_raw_text(self, path='.'):\n cells = self.get_cells()\n arrays = []\n for cell in cells:\n arrays.append(cell.data)\n array = np.concatenate(arrays)\n fn = os.path.join(path, self.label + '.txt')\n fmt = []\n p = re.compile('(\\w)(\\d+)')\n for key, value in self.datatype:\n m = p.search(value)\n if m:\n kind, size = m.groups()\n # strings\n if kind == 'S':\n add = '%{}c'.format(size)\n # integers\n elif kind in ['u', 'i']:\n add = '%d'\n else:\n add = '%.8e'\n else:\n add = '%.8e'\n fmt.append(add)\n np.savetxt(fn, array, fmt=fmt, delimiter='\\t')\n return","def save_scan_on_file(self,branch=1):\n if branch==1:\n np.save(file=self.scan_path_T,arr=self.thr_scan_matrix)\n else:\n np.save(file=self.scan_path_E, arr=self.thr_scan_matrix)\n # if branch==1:\n # f = open(self.scan_path_T, 'w')\n # else:\n # f = open(self.scan_path_E, 'w')\n #\n # for T in range(0, 8):\n # f.write(\"Tiger {}\".format(T))\n # f.write(\"Frames\\n\")\n # for i in range(0, 64):\n # f.write(\"\\nChannel {}\\n\".format(i))\n #\n # for j in range (0,64):\n # if self.thr_scan_frames[T, i, j]:\n # f.write(\"{},\".format(self.thr_scan_frames[T, i, j]))\n # else:\n # f.write(\"0,\")\n #\n # f.write(\"\\nEvents\\n\")\n # for i in range(0, 64):\n # f.write(\"\\nChannel {}\\n\".format(i))\n #\n # for j in range (0,64):\n # if self.thr_scan_frames[T, i, j]:\n # f.write(\"{},\".format(self.thr_scan_matrix[T, i, j]))\n # else:\n # f.write(\"0,\")\n # f.write(\"\\n\")\n #\n # f.close()","def write_cell(self, cell, timestamp=None):\n cell.to_gds(self._outfile, self._res, timestamp)\n return self","def writebytes(self, *args) -> \"int\":\n return _ida_fpro.qfile_t_writebytes(self, *args)","def depth_write(filename, depth):\n height,width = depth.shape[:2]\n f = open(filename,'wb')\n # write the header\n f.write(TAG_CHAR)\n np.array(width).astype(np.int32).tofile(f)\n np.array(height).astype(np.int32).tofile(f)\n \n depth.astype(np.float32).tofile(f)\n f.close()","def write (self, file):\n\t\tfile.write (self.pack ())","def write_to_file(fib_details: dict):\n pass # TODO: Replace with implementation!","def save_GRID( self , filename ):\n self._fwrite_GRID( filename )","def write(self, binary_log: BinaryLoggable) -> None:\n if binary_log == None:\n return #possibly raise exception\n record_array = binary_log.to_bytes()\n record_len = len(record_array)\n if record_len == 0:\n return #possibly raise exception\n\n log_name = type(binary_log).__name__\n self.file_map.setdefault(log_name, [])\n\n # Writes log_name size and log_name to the end of file\n self.bfile.seek(0,os.SEEK_END)\n self.bfile.write(len(log_name).to_bytes(self.IntLength, byteorder='big'))\n self.bfile.write(bytearray(log_name, self.Encoding))\n\n # Write byte_array size and byte array\n self.bfile.write(record_len.to_bytes(self.IntLength, byteorder='big'))\n self.file_map[log_name].append([self.bfile.tell(),record_len])\n self.bfile.write(record_array)","def export_cell_budget(cell_budget_file, grid,\n binary_grid_file=None,\n kstpkper=None, text=None, idx=0,\n precision='single',\n output_path='postproc', suffix=''):\n print('Exporting cell budget info...')\n print('file: {}'.format(cell_budget_file))\n print('binary grid file: {}'.format(binary_grid_file))\n\n cbbobj = bf.CellBudgetFile(cell_budget_file, precision=precision)\n if kstpkper is None:\n kstpkper = cbbobj.get_times()[idx]\n if np.isscalar(kstpkper[0]):\n kstpkper = [kstpkper]\n\n pdfs_dir, rasters_dir, shps_dir = make_output_folders(output_path)\n if text is not None and not isinstance(text, list):\n text = [text]\n\n names = [r.decode().strip() for r in cbbobj.get_unique_record_names()]\n if text is not None:\n names = list(set(text).intersection(names))\n if len(names) == 0:\n print('{} not found in {}'.format(' '.join(text), cell_budget_file))\n\n outfiles = []\n for kstp, kper in kstpkper:\n print('stress period {}, timestep {}'.format(kper, kstp))\n for variable in names:\n if variable == 'FLOW-JA-FACE':\n df = get_flowja_face(cbbobj, binary_grid_file=binary_grid_file,\n kstpkper=(kstp, kper), idx=idx,\n precision=precision)\n # export the vertical fluxes as rasters\n # (in the downward direction; so fluxes between 2 layers\n # would be represented in the upper layer)\n if df is not None and 'kn' in df.columns and np.any(df['kn'] < df['km']):\n vflux = df.loc[(df['kn'] < df['km'])]\n nlay = vflux['km'].max()\n _, nrow, ncol = grid.shape\n vflux_array = np.zeros((nlay, nrow, ncol))\n vflux_array[vflux['kn'].values,\n vflux['in'].values,\n vflux['jn'].values] = vflux.q.values\n data = vflux_array\n else:\n data = get_bc_flux(cbbobj, variable, kstpkper=(kstp, kper), idx=idx)\n if data is None:\n print('{} not exported.'.format(variable))\n continue\n outfile = '{}/{}_per{}_stp{}{}.tif'.format(rasters_dir, variable, kper, kstp, suffix)\n export_array(outfile, data, grid, nodata=0)\n outfiles.append(outfile)\n return outfiles","def Write(self):\n table_data = self._TABLE.build(self._offsets)\n self._zip_file.writestr(self._stream_name, table_data)","def write(self, filename):\n f = open(filename, 'bw')\n\n # file header (14)\n f.write(char('B'))\n f.write(char('M'))\n f.write(dword(14 + 40 + self.width * self.height * 3))\n f.write(dword(0))\n f.write(dword(14 + 40))\n\n # image header (40)\n f.write(dword(40))\n f.write(dword(self.width))\n f.write(dword(self.height))\n f.write(word(1))\n f.write(word(24))\n f.write(dword(0))\n f.write(dword(0))\n f.write(dword(self.width * self.height * 3))\n f.write(dword(0))\n f.write(dword(0))\n f.write(dword(0))\n f.write(dword(0))\n\n # pixel data\n for x in range(self.height):\n for y in range(self.width):\n f.write(self.pixels[x][y])\n f.close()","def write_CASTEP_cell(CASTEP_cell,filename):\n f=open(seedname+\".cell\",\"r\")\n castep_cell = f.readlines()\n global hashes\n f=StringIO.StringIO()\n f.write(\"%BLOCK LATTICE_CART\\n\")\n for i in xrange(3):\n f.write(\"{0[0]:>20.15f} {0[1]:>20.15f} {0[2]:>20.15f}\\n\".format(\n (CASTEP_cell[\"lattvec\"][:,i]*10).tolist()))\n f.write(\"%ENDBLOCK LATTICE_CART\\n\")\n f.write(\"\\n\")\n f.write(\"%BLOCK POSITIONS_FRAC\\n\")\n k = 0\n for i in xrange(len(CASTEP_cell[\"numbers\"])):\n for j in xrange(CASTEP_cell[\"numbers\"][i]):\n l = k + j\n f.write(\"{0}\".format(\"\".join(CASTEP_cell[\"elements\"][i]))) \n f.write(\"{0[0]:>20.15f} {0[1]:>20.15f} {0[2]:>20.15f}\\n\".format(\n CASTEP_cell[\"positions\"][:,l].tolist()))\n k += j + 1\n f.write(\"%ENDBLOCK POSITIONS_FRAC\\n\")\n\n # Copy everything after '%ENDBLOCK POSITIONS_FRAC'\n for index, line in enumerate(castep_cell):\n if '%ENDBLOCK POSITIONS_FRAC' in line.upper():\n index_end = index\n for i in xrange(index_end+1,len(castep_cell)):\n f.write(castep_cell[i])\n with open(filename,\"w\") as finalf:\n finalf.write(f.getvalue())\n f.close()","def write_record(self, *items):\n items = tuple(np.asarray(item) for item in items)\n total_size = sum(item.nbytes for item in items)\n\n nb = np.array([total_size], dtype=self._header_dtype)\n\n nb.tofile(self._fp)\n for item in items:\n item.tofile(self._fp)\n nb.tofile(self._fp)","def _write(self):\n f = FortranFile(self.filename,mode='w')\n # Default omnivor binary header\n f.writeInts ( self.data['MK'] , 'i' ) \n f.writeInts ( self.data['itime'] , 'i' ) \n f.writeString ( self.data['version'] ) \n f.writeInts ( self.data['file_id'] , 'i' ) \n f.writeString ( self.data['sversion'] ) \n # Velocity field\n f.writeString ( self.data['stype'] ) \n f.writeInts ( self.data['is_grid'] , 'i' ) \n f.writeInts ( self.data['nCPs'] , 'i' ) \n if self.data['MK'] == 8:\n real_char='d'\n else:\n real_char='f'\n if self.data['is_grid']:\n f.writeInts ( self.data['n1'] , 'i' ) \n f.writeInts ( self.data['n2'] , 'i' ) \n f.writeInts ( self.data['n3'] , 'i' ) \n f.writeInts ( self.data['is_straight'] , 'i' ) \n f.writeReals ( self.data['v1'] , real_char ) \n f.writeReals ( self.data['v2'] , real_char ) \n f.writeReals ( self.data['v3'] , real_char ) \n\n CPs = self.data['CPs'].flatten(order = 'F')\n Utot = self.data['Utot'].flatten(order = 'F')\n f.writeReals(CPs,real_char)\n f.writeReals(Utot,real_char)","def write_file(_data, _label, _clinical, _contour, _type):\n pickle.dump(np.array(_data), open(_type + '_data.pxl', 'wb'))\n pickle.dump(np.array(_label), open(_type + '_label.pxl', 'wb'))\n pickle.dump(np.array(_clinical), open(_type + '_clinical.pxl', 'wb'))\n pickle.dump(np.array(_contour), open(_type + '_contour.pxl', 'wb'))","def write_data(self, filename,\n columns=('Q', 'R', 'dR'),\n header=None):\n if header is None:\n header = \"# %s\\n\"%' '.join(columns)\n with open(filename, 'wb') as fid:\n fid.write(asbytes(header))\n data = np.vstack([getattr(self, c) for c in columns])\n np.savetxt(fid, data.T)","def _write(self, out_file):\n out_file.write(' '.encode()) # pad byte\n out_file.write('{:4d}'.format(self.key).encode())\n out_file.write(self.code.encode())\n out_file.write((' '*18).encode()) # pad bytes\n out_file.write('{:12d}'.format(self.numnod).encode())\n out_file.write((' '*37).encode()) # pad bytes\n out_file.write('{:1d}'.format(self.format).encode())\n out_file.write('\\n'.encode())\n\n for node in self.nodes:\n if self.format < 2:\n out_file.write(' '.encode())\n out_file.write('-1'.encode())\n if self.format == 0:\n out_file.write('{:5d}'.format(node.number).encode())\n else:\n out_file.write('{:10d}'.format(node.number).encode())\n for i in range(3):\n out_file.write('{:12.5E}'.format(node.pos[i]).encode())\n out_file.write('\\n'.encode())\n else:\n out_file.write(struct.pack('i', node.number))\n if self.format == 2:\n out_file.write(struct.pack('fff', *node.pos))\n else:\n out_file.write(struct.pack('ddd', *node.pos))\n\n if self.format < 2:\n out_file.write(' -3\\n'.encode()) # last record for ascii only","def write(self, filename):\n bvh_string = self.generate_bvh_string()\n if filename[-4:] == '.bvh':\n filename = filename\n else:\n filename = filename + '.bvh'\n with open(filename, 'w') as outfile:\n outfile.write(bvh_string)","def write_to(self, filename):\n with open(filename, 'w') as f:\n for xx, yy, zz, ww in zip(self.x, self.y, self.field, self.weight):\n f.write(\"%s %s %s %s\\n\" % (xx, yy, zz, ww))\n logger.info(\"Written data into file {0}\".format(filename))","def to_binary(inputs, outputs, filename_label=None):\n inputs.write(filename_label, filename_label=filename_label)\n outputs.write(filename_label, filename_label=filename_label)","def save_to_file(grid, filepath):\n outfile = codecs.open(filepath, mode='w+', encoding='utf-8')\n outfile.writelines([((''.join(row)) + u'\\n') for row in grid])","def test_write_bintable(self):\n from ..io.util import write_bintable, fitsheader\n #\n # Input: Table\n #\n hdr = fitsheader(dict(A=1, B=2))\n hdr['C'] = ('BLAT', 'FOO')\n data = Table()\n data['X'] = [1, 2, 3]\n data['Y'] = [3, 4, 5]\n write_bintable(self.testfile, data, header=hdr)\n #\n # Standard suite of table tests.\n #\n result, newhdr = fits.getdata(self.testfile, header=True)\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\n for colname in data.dtype.names:\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\n self.assertEqual(newhdr.comments['C'], 'FOO')\n for key in hdr.keys():\n self.assertIn(key, newhdr)\n self.assertIn('DATASUM', newhdr)\n self.assertIn('CHECKSUM', newhdr)\n os.remove(self.testfile)\n #\n # Input: ndarray\n #\n hdr = dict(A=1, B=2)\n data = data.as_array()\n write_bintable(self.testfile, data, header=hdr)\n #\n # Standard suite of table tests.\n #\n result, newhdr = fits.getdata(self.testfile, header=True)\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\n for colname in data.dtype.names:\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\n # self.assertEqual(newhdr.comments['C'], 'FOO')\n for key in hdr.keys():\n self.assertIn(key, newhdr)\n self.assertIn('DATASUM', newhdr)\n self.assertIn('CHECKSUM', newhdr)\n os.remove(self.testfile)\n #\n # Input: dictionary\n #\n hdr = dict(A=1, B=2)\n d = dict(X=np.array([1, 2, 3]), Y=np.array([3, 4, 5]))\n write_bintable(self.testfile, d, header=hdr)\n #\n # Standard suite of table tests.\n #\n result, newhdr = fits.getdata(self.testfile, header=True)\n\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\n\n for colname in data.dtype.names:\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\n # self.assertEqual(newhdr.comments['C'], 'FOO')\n for key in hdr.keys():\n self.assertIn(key, newhdr)\n self.assertIn('DATASUM', newhdr)\n self.assertIn('CHECKSUM', newhdr)\n os.remove(self.testfile)\n #\n # Input: Table with column comments.\n #\n hdr = fitsheader(dict(A=1, B=2))\n hdr['C'] = ('BLAT', 'FOO')\n data = Table()\n data['X'] = [1, 2, 3]\n data['Y'] = [3, 4, 5]\n write_bintable(self.testfile, data, header=hdr,\n comments={'X': 'This is X', 'Y': 'This is Y'},\n units={'X': 'mm', 'Y': 'mm'})\n #\n # Standard suite of table tests.\n #\n result, newhdr = fits.getdata(self.testfile, header=True)\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\n for colname in data.dtype.names:\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\n # self.assertEqual(newhdr.comments['C'], 'FOO')\n for key in hdr.keys():\n self.assertIn(key, newhdr)\n self.assertIn('DATASUM', newhdr)\n self.assertIn('CHECKSUM', newhdr)\n self.assertEqual(newhdr['TTYPE1'], 'X')\n self.assertEqual(newhdr.comments['TTYPE1'], 'This is X')\n self.assertEqual(newhdr['TTYPE2'], 'Y')\n self.assertEqual(newhdr.comments['TTYPE2'], 'This is Y')\n self.assertEqual(newhdr['TUNIT1'], 'mm')\n self.assertEqual(newhdr.comments['TUNIT1'], 'X units')\n self.assertEqual(newhdr['TUNIT2'], 'mm')\n self.assertEqual(newhdr.comments['TUNIT2'], 'Y units')\n #\n # Input: Table with no EXTNAME, existing file\n #\n write_bintable(self.testfile, data, header=hdr)\n #\n # Input: Table with EXTNAME, existing file\n #\n write_bintable(self.testfile, data, header=hdr, extname='FOOBAR')\n #\n # Standard suite of table tests.\n #\n result, newhdr = fits.getdata(self.testfile, header=True, extname='FOOBAR')\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\n for colname in data.dtype.names:\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\n # self.assertEqual(newhdr.comments['C'], 'FOO')\n for key in hdr.keys():\n self.assertIn(key, newhdr)\n self.assertIn('DATASUM', newhdr)\n self.assertIn('CHECKSUM', newhdr)\n #\n # Input: Table with existing EXTNAME, existing file\n #\n write_bintable(self.testfile, data, header=hdr, extname='FOOBAR')\n #\n # Input: Table with EXTNAME, existing file, overwrite\n #\n write_bintable(self.testfile, data, header=hdr, extname='FOOBAR', clobber=True)","def writecif(atoms, coords, filename, text=''):\n \n f = open(filename+'.cif', 'w')\n f.write(text)\n \n for atom, coord in zip(atoms, coords):\n f.write(\"{} {} {} {}\\n\".format(atom, coord[0], coord[1], coord[2]))\n \n f.close()","def write_body(filepath, *coords):\n with open(filepath, 'w') as outfile:\n outfile.write('{}\\n'.format(len(coords[0])))\n with open(filepath, 'ab') as outfile:\n numpy.savetxt(outfile, numpy.c_[coords])","def save(self, file):\n boulders = []\n elephants = []\n rhinos = []\n for i in range(5):\n for j in range(5):\n if self[i][j]!= 0:\n piece = self[i][j]\n L = []\n if not isinstance(self[i][j], Boulder):\n L.append(self[i][j].direction[0])\n L.append(self[i][j].direction[1])\n if piece.species == \"Elephant\":\n elephants.append(\"(\" + str(i) + \",\" + str(j)+ \") : np.array([\"+str(L[0])+ \",\" + str(L[1])+\"])\")\n elif piece.species == \"Rhinoceros\":\n rhinos.append(\"(\"+str(i)+\",\" +str(j)+ \") : np.array([\"+str(L[0]) + \",\" + str(L[1])+\"])\")\n elif isinstance(piece, Boulder):\n boulders.append(\"(\" + str(i) + \",\" + str(j) + \")\")\n file.write(\"# King of Siam GameFile \\n\\nplayer_turn {\\n \" + self.playerTurn + \"\\n}\\n\\n\")\n file.write(\"Boulder {\")\n for k in range(len(boulders)):\n file.write(\"\\n \" + boulders[k] + \";\")\n file.write(\"\\n}\\n\\nElephant {\")\n for elt in elephants:\n file.write(\"\\n \" + elt + \";\")\n file.write(\"\\n}\\n\\nRhinoceros {\")\n for elt in rhinos:\n file.write(\"\\n \" + elt + \";\")\n file.write(\"\\n}\")\n\n file.close()","def write(self, row):\n bytes = struct.pack(self.pack_format, *row)\n self.f.write(bytes)","def write_flow(flow, filename):\n f = open(filename, 'wb')\n magic = np.array([202021.25], dtype=np.float32)\n (height, width) = flow.shape[0:2]\n w = np.array([width], dtype=np.int32)\n h = np.array([height], dtype=np.int32)\n magic.tofile(f)\n w.tofile(f)\n h.tofile(f)\n flow.tofile(f)\n f.close()","def _writeWaveform(self, fo, header='', binary=False):\n # TODO: Write channel data to file\n pass","def write( self, NewFilename='', Integer=True ):\n try:\n if NewFilename != '':\n self.name=NewFilename\n Output = open( self.name, 'w' )\n Output.write( 'ncols\\t\\t %d\\n' % self.ncols )\n Output.write( 'nrows\\t\\t %d\\n' % self.nrows )\n Output.write( 'xllcorner\\t\\t %f\\n' % self.xllcorner)\n Output.write( 'yllcorner\\t\\t %f\\n' % self.yllcorner)\n Output.write( 'cellsize\\t\\t %f\\n' % self.cellsize)\n if Integer:\n Output.write( 'NODATA_value\\t\\t %d\\n' % int(self.nodata) )\n else:\n Output.write( 'NODATA_value\\t\\t %f\\n' % self.nodata )\n for row in range( self.nrows-1,-1,-1 ):\n record = []\n for col in range( self.ncols ):\n if Integer:\n record.append( str( int( round( self.data[row,col]) ) ) )\n else:\n record.append( str(self.data[row,col]) )\n Output.write( string.join(record, ' ')+'\\n' )\n Output.close()\n except:\n print \"Error writing grid ::\", self.name","def write_flow(flow, filename):\n f = open(filename, 'wb')\n magic = numpy.array([202021.25], dtype=numpy.float32)\n (height, width) = flow.shape[0:2]\n w = numpy.array([width], dtype=numpy.int32)\n h = numpy.array([height], dtype=numpy.int32)\n magic.tofile(f)\n w.tofile(f)\n h.tofile(f)\n flow.tofile(f)\n f.close()","def write(self, fname):\n pass","def write(self, filename, **kwargs):\n self.to_table().write(filename, format='fits', **kwargs)","def test_file_bin_readwrite(self):\n FileWriter(self.binary_path).write_bin(self.binary_string)\n bin_data = FileReader(self.binary_path).read_bin()\n self.assertEqual(bin_data, self.binary_string)","def write_table(table, file_path):\n\n\twith open(file_path, 'w') as file:\n\t\tfile.write(table)","def write_ptm_gridfile(self,fn):\n vertex_hdr = \" Vertex Data: vertex_number, x, y\"\n poly_hdr = \" Polygon Data: polygon_number, number_of_sides,center_x, center_y, center_depth, side_indices(number_of_sides), marker(0=internal,1=open boundary)\"\n side_hdr = \" Side Data: side_number, side_depth, node_indices(2), cell_indices(2), marker(0=internal,1=external,2=flow boundary,3=open boundary)\"\n\n with open(fn,'wt') as fp:\n # write header counts\n fp.write(\" Number of Vertices\\n\")\n fp.write(\" %20d\\n\"%self.Nnodes())\n fp.write(\" Number of Polygons\\n\")\n fp.write(\" %20d\\n\"%self.Ncells())\n fp.write(\" Number of Sides\\n\")\n fp.write(\" %20d\\n\"%self.Nedges())\n fp.write(\" NODATA (land) value\\n\")\n fp.write(\" -9999.000000000\\n\")\n\n # write vertex info\n fp.write(vertex_hdr+\"\\n\")\n for v in range(self.Nnodes()):\n fp.write(\" %10d %16.7f %16.7f\\n\"%(v+1,\n self.nodes['x'][v,0],\n self.nodes['x'][v,1]))\n\n # write polygon info\n fp.write(poly_hdr+\"\\n\")\n cell_write_str1 = \" %10d %10d %16.7f %16.7f %16.7f \"\n cell_depths = self.cell_depths()\n for e in range(self.Ncells()):\n edges = self.cells['edges'][e,:]\n edges[edges<0] = -1\n edge_str = \" \".join( [\"%10d\"%(s+1) for s in edges] )\n edge_str = edge_str+\" %10d\\n\"%(self.cells['mark'][e])\n nsides = sum(edges>=0)\n fp.write(cell_write_str1%(e+1,\n nsides,\n self.cells['_center'][e,0],\n self.cells['_center'][e,1],\n cell_depths[e]))\n fp.write(edge_str)\n \n # write side info\n fp.write(side_hdr+\"\\n\")\n edge_depths = self.edge_depths()\n edge_write_str = \" %10d %16.7f %10d %10d %10d %10d %10d\\n\"\n for s in range(self.Nedges()):\n edges = self.edges['cells'][s,:]\n edges[edges<0] = -1 \n nodes = self.edges['nodes'][s,:]\n nodes[nodes<0] = -1\n fp.write(edge_write_str%(s+1,\n edge_depths[s],\n nodes[0]+1,\n nodes[1]+1,\n edges[0]+1,\n edges[1]+1,\n self.edges['mark'][s]))","def write(self, file, endian=None):\n if endian is None:\n endian = self.endian\n for item in BINARY_FILE_HEADER_FORMAT:\n length, name, _ = item\n # Unpack according to different lengths.\n if length == 2:\n format = ('%sh' % endian).encode('ascii', 'strict')\n # Write to file.\n file.write(pack(format, getattr(self, name)))\n # Update: Seems to be correct. Two's complement integers seem to be\n # the common way to store integer values.\n elif length == 4:\n format = ('%si' % endian).encode('ascii', 'strict')\n # Write to file.\n file.write(pack(format, getattr(self, name)))\n # These are the two unassigned values in the binary file header.\n elif name.startswith('unassigned'):\n temp = getattr(self, name)\n if not isinstance(temp, bytes):\n temp = str(temp).encode('ascii', 'strict')\n temp_length = len(temp)\n # Pad to desired length if necessary.\n if temp_length != length:\n temp += b'\\x00' * (length - temp_length)\n file.write(temp)\n # Should not happen.\n else:\n raise Exception","def testWriteBinaryData(self):\n file_writer = writers.FileWriter()\n\n file_writer._file = io.BytesIO()\n\n file_writer.WriteBinaryData(b'Binary data')\n\n file_writer._file.seek(0, os.SEEK_SET)\n output_data = file_writer._file.read()\n expected_output_data = b'Binary data'\n self.assertEqual(output_data, expected_output_data)","def write_bi_code_to_file(bi_code, file_path):\r\n with open(file_path, 'w') as file:\r\n for i in bi_code:\r\n file.write(f'{i}\\n')","def write_checkpoint(self):\n self.file_checkpoint_data = open(self.path_checkpoint, \"a+\")\n array_to_write = [str(self.radious), self.type_feature, self.type_filtering, self.h_filterig]\n self.file_checkpoint_data.write(','.join(array_to_write) + \"\\n\")\n self.file_checkpoint_data.flush()","def write_grid2d(grid_file, grid2d):\n with grid_file.open('w') as f:\n for row in grid2d['label']:\n f.write('\\t'.join(row) + '\\n')","def write_bin(raw):\n a = raw.astype('i1')\n b = a.reshape((-1,2))\n\n b[:,1] = b[:,1] << 4\n\n c = np.bitwise_or(b[:,0], b[:,1]).astype('i1')\n\n return c","def write_to_file(self, filename):\n self.octree.write(str.encode(filename))\n print(\"Save octomap to \"+filename)","def add_cells(self):\n # To delete all common cells\n self.delete_cells()\n if self.removed_last_bracket:\n new_lib = self.base_doc + self.cell_doc + '\\n}\\n'\n else:\n end_part = self.base_doc[-4:] \n if '}' in end_part:\n new_lib = self.base_doc[0:-4] + '\\n\\t\\t' + self.cell_doc + '\\n}\\n'\n # print(new_lib)\n try: \n with open(self.output_file, \"w\") as file_doc:\n file_doc.write(new_lib)\n return True\n except:\n return False","def write_bed_file(bed_dict, out_file_name):\n with open(os.getcwd() + '/' + ntpath.basename(out_file_name), 'w') as out_file:\n for header in bed_dict.keys():\n for coordinates in bed_dict[header]:\n out_file.write(\n '%s\\t%r\\t%r\\n' %(header[1:], coordinates[0], coordinates[1])\n )","def write_to_file(board, output_file = \"solution.sud\"):\n with open(output_file, \"w\") as f:\n for i in range(n):\n if i and i%3==0:\n f.write(\"------+-------+------\\n\")\n for j in range(n): \n if j and j%3==0:\n f.write(\"| \")\n if len(board[i][j]) == 1:\n f.write(str(board[i][j][0]) + \" \")\n else:\n f.write(\". \")\n elif j==8:\n if len(board[i][j]) == 1:\n f.write(str(board[i][j][0]) + \"\\n\")\n else:\n f.write(\".\\n\")\n else:\n if len(board[i][j]) == 1:\n f.write(str(board[i][j][0]) + \" \")\n else:\n f.write(\". \")\n return 0","def write_file(bytes, path: str):\n\n newFile = open(path + \".rex\", \"wb\")\n newFile.write(bytes)\n return True","def write_file(self):\n if self._write_file == None:\n return\n\n try:\n out = file(self._write_file, \"w\")\n except IOError, e:\n print e\n sys.exit(1)\n out.writelines(\"A cases\") \n out.close()","def write_to_file(output, data, datafields):\n if (len(data) != len(datafields)):\n print \"Error! number of data fields != number of headers!\"\n print 'len: ', len(data), len(datafields)\n print 'shape: ', np.shape(data), np.shape(datafields)\n\n ofile = open(output,'w')\n ofile.write(\"# g(r) in the xy-plane from 2Drdf.py\\n\")\n header = \"# chunk \"\n for element in datafields:\n header += element + \" \"\n\n header = header + '\\n'\n ofile.write(header)\n \n it = 0\n for i in xrange(len(data[0])):\n line = str(it) + \" \"\n it += 1\n for j in xrange(len(data)):\n line += str(float(data[j][i])) + \" \"\n line += \"\\n\"\n ofile.write(line)\n \n ofile.close()\n print \"Finished writing file: \", output","def cam_write(filename, M, N):\n f = open(filename,'wb')\n # write the header\n f.write(TAG_CHAR)\n M.astype('float64').tofile(f)\n N.astype('float64').tofile(f)\n f.close()","def saveScalarStructuredGridVTK_binary(scalar,scalar_name,x,y,z,filename,dims):\n \n numEl_size = x.size; numEl = np.prod(numEl_size);\n # open the file and write the ASCII header:\n file = open(filename,'w')\n file.write('# vtk DataFile Version 3.0\\n')\n file.write('VTK file for data post-processed with Python\\n')\n file.write('Binary\\n\\n')\n file.write('DATASET STRUCTURED_GRID\\n')\n file.write('DIMENSIONS %d %d %d \\n'%(dims[0],dims[1],dims[2]))\n file.write('POINTS %d float\\n'%(numEl))\n file.close()\n \n # append binary x,y,z data\n file = open(filename,'ab')\n for i in range(len(x)): # there really needs to be a better way.\n pt = [x[i],y[i],z[i]]\n pt_buf = array('f',pt)\n pt_buf.byteswap()\n file.write(pt_buf)\n \n \n file.close()\n \n # append another ASCII sub header for the scalar data\n file = open(filename,'a')\n file.write('POINT_DATA %d \\n'%numEl)\n file.write('SCALARS %s int\\n'%scalar_name)\n file.write('LOOKUP_TABLE default\\n')\n file.close()\n \n # append binary scalar data\n file = open(filename,'ab')\n p_buf = array('f',scalar); p_buf.byteswap()\n file.write(p_buf)\n file.close()","def add_binary(self):\n # Construct a binary representation for each genotype\n binary = utils.genotypes_to_binary(self.wildtype,\n self.genotypes,\n self.mutations\n )\n\n # Add this as a column to the map.\n self.data['binary'] = binary","def save_elem_file(self, output):\n with open(output, 'wb') as fid:\n self._write_elem_header(fid)\n self._write_nodes(fid)\n self._write_elements(fid)\n self._write_neighbors(fid)","def write(self, filename):\n pass","def write(self, filename):\n pass","def write_offsets(self):\n\n for offset in self.offsets:\n self.db_file.write(struct.pack(\"<I\", offset))","def write_object_file_to_file(self, file_name):\n with open(file_name, 'wb+') as file:\n file.write(self.object_file.to_binary_array())","def write_binary(self,value):\n self.write_uint32(len(value))\n self.data.extend(value)","def write(data):","def write_opcodes(path, opcodes):\n with open(path, \"w\") as file_handler:\n for opcode in opcodes:\n file_handler.write(opcode + \"\\n\")","def write_bytes_to_file(bytes, filename):\n try:\n with open(filename, mode=\"bx\") as file:\n file.write(bytes)\n except FileExistsError:\n os.remove(filename)\n ResourceHandler.write_bytes_to_file(bytes, filename)\n except Exception as e:\n print(e)","def write(filename):\n print(uc.write(filename))","def update_binary(self, offset, data):\n log.debug(\"write binary {0} to {1}\".format(offset, offset+len(data)))\n cmd = bytearray([0x00, 0xD6, offset/256, offset%256, len(data)])\n cmd = cmd + bytearray(data)\n rsp = self.transceive(cmd)\n if rsp[-2:] != \"\\x90\\x00\":\n raise Type4TagError(rsp[-2:])","def write(self, filename, data, hdr):\n pass","def outputBigMatrix(cellNames, results, outFname, isGene=False):\n logging.info(\"Writing data to file %s\" % outFname)\n ofh = open(outFname, \"w\")\n # write header\n if isGene:\n ofh.write(\"#gene\\t%s\\n\" % \"\\t\".join(cellNames))\n else:\n ofh.write(\"#transcript\\t%s\\n\" % \"\\t\".join(cellNames))\n \n # create a sorted list of all transcript names\n logging.info(\"Getting transcript IDs\")\n allTrans = set()\n for res in results:\n allTrans.update(res)\n allTrans = list(allTrans)\n allTrans.sort()\n\n # write out matrix\n logging.info(\"Iterating over transcript IDs and writing to tab file\")\n for trans in allTrans:\n ofh.write(\"%s\\t\" % trans)\n row = []\n for countDict in results:\n row.append(str(countDict.get(trans, 0)))\n ofh.write(\"\\t\".join(row))\n ofh.write(\"\\n\")\n ofh.close()\n\n # also output as a binary file for now\n # it's a lot easier and faster to parse, at least for python scripts\n # can be read from python with a single line:\n # matrix = marshal.load(open(\"data.tab.marshal\"))\n # matrix is then a nested hash: cellName -> transcript -> count\n binPath = outFname+\".marshal\"\n logging.info(\"Writing %s\" % binPath)\n allData = {}\n for name, transDict in zip(cellNames, results):\n allData[name] = transDict\n marshal.dump(allData, open(binPath, \"wb\"))","def write_files(self, basedir):\n outdir = basedir / self.type\n outdir.mkdir(parents=True, exist_ok=True)\n\n for point, row in zip(self.points, self.array):\n filepath = outdir / point\n with filepath.open('w') as f:\n idx = 0\n for ikey in self.pardict.keys():\n f.write(\"{} {}\\n\".format(ikey, row[idx]))\n idx += 1\n logging.debug('wrote %s', filepath)","def _write(self, out_file):\n out_file.write(' '.encode()) # pad byte\n out_file.write('{:4d}'.format(self.key).encode())\n out_file.write(self.code.encode())\n out_file.write((' '*18).encode()) # pad bytes\n out_file.write('{:12d}'.format(self.numelem).encode())\n out_file.write((' '*37).encode()) # pad bytes\n out_file.write('{:1d}'.format(self.format).encode())\n out_file.write('\\n'.encode())\n\n for elem in self.elems:\n if self.format < 2:\n out_file.write(' -1'.encode())\n if self.format == 0:\n out_file.write('{:5d}'.format(elem.number).encode())\n else:\n out_file.write('{:10d}'.format(elem.number).encode())\n out_file.write('{:5d}'.format(elem.type).encode())\n out_file.write('{:5d}'.format(elem.group).encode())\n out_file.write('{:5d}'.format(elem.material).encode())\n out_file.write('\\n'.encode())\n num_nodes = FRDElem.nodesPerType[elem.type]\n num_lines = int(num_nodes/(5*(3-self.format)+1))+1\n for j in range(num_lines):\n out_file.write(' -2'.encode()) # pad byte and key = -2\n k_start = j*5*(3-self.format)\n k_end = min(num_nodes, (j+1)*5*(3-self.format))\n if self.format == 0:\n for k in range(k_start, k_end):\n out_file.write(\n '{:5d}'.format(elem.nodes[k]).encode())\n else:\n for k in range(k_start, k_end):\n out_file.write(\n '{:10d}'.format(elem.nodes[k]).encode())\n out_file.write('\\n'.encode()) # eol\n else:\n out_file.write(struct.pack('i', elem.number))\n out_file.write(struct.pack('i', elem.type))\n out_file.write(struct.pack('i', elem.group))\n out_file.write(struct.pack('i', elem.material))\n out_file.write(struct.pack('i'*num_nodes, *elem.nodes))\n\n if self.format < 2:\n out_file.write(' -3\\n') # last record for ascii only","def write_data():","def write_neighnet(pathfolder, nif, neighnet, methodvalues):\n ## Generate namefile\n namefile = generate_namefile(pathfolder, methodvalues)\n\n ## Writting\n db = shelve.open(namefile)\n db['nif'] = nif\n db['neighnet'] = neighnet\n db['methodvalues'] = methodvalues\n db.close()","def saveDataToFile(fullFilename, binaryData):\n with open(fullFilename, 'wb') as fp:\n fp.write(binaryData)\n fp.close()\n # logging.debug(\"Complete save file %s\", fullFilename)","def to_file(c, path, seq_types=None):\n with open(path, \"w\") as f:\n f.write(circuit_to_verilog(c, seq_types))"],"string":"[\n \"def write_binary(self, path):\\n return\",\n \"def write_df_to_binary(file_name_mask, df):\\n write_matrix_to_binary(file_name_mask + '-value.bin', df.values)\\n with open(file_name_mask + '-name.txt', 'w') as f:\\n f.write(\\\"\\\\t\\\".join(df.index))\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"\\\\t\\\".join(df.columns))\\n f.write(\\\"\\\\n\\\")\",\n \"def write_gds(self, outfile, cells=None, timestamp=None, binary_cells=None):\\n close = True\\n if hasattr(outfile, \\\"__fspath__\\\"):\\n outfile = open(outfile.__fspath__(), \\\"wb\\\")\\n elif isinstance(outfile, (basestring, Path)):\\n outfile = open(outfile, \\\"wb\\\")\\n else:\\n close = False\\n now = datetime.datetime.today() if timestamp is None else timestamp\\n name = self.name if len(self.name) % 2 == 0 else (self.name + \\\"\\\\0\\\")\\n outfile.write(\\n struct.pack(\\n \\\">5H12h2H\\\",\\n 6,\\n 0x0002,\\n 0x0258,\\n 28,\\n 0x0102,\\n now.year,\\n now.month,\\n now.day,\\n now.hour,\\n now.minute,\\n now.second,\\n now.year,\\n now.month,\\n now.day,\\n now.hour,\\n now.minute,\\n now.second,\\n 4 + len(name),\\n 0x0206,\\n )\\n + name.encode(\\\"ascii\\\")\\n + struct.pack(\\\">2H\\\", 20, 0x0305)\\n + _eight_byte_real(self.precision / self.unit)\\n + _eight_byte_real(self.precision)\\n )\\n if cells is None:\\n cells = self.cells.values()\\n else:\\n cells = [self.cells.get(c, c) for c in cells]\\n if len(cells) == 0:\\n warnings.warn(\\\"[GDSPY] Creating a GDSII file without any cells.\\\")\\n for cell in cells:\\n cell.to_gds(outfile, self.unit / self.precision, timestamp=timestamp)\\n if binary_cells is not None:\\n for bc in binary_cells:\\n outfile.write(bc)\\n outfile.write(struct.pack(\\\">2H\\\", 4, 0x0400))\\n if close:\\n outfile.close()\",\n \"def write_to_binary_file(self, filename):\\n\\n self.octree.writeBinary(str.encode(filename))\",\n \"def bin_writer(fpath, fname, data):\\n path = fpath + fname + '.dat'\\n with open(path, 'ab') as file:\\n for row in data:\\n file.write(row.encode('utf-8'))\\n return None\",\n \"def write_bin(file, binary, buffer=None, append=True):\\n\\n # Get current stream, default or not.\\n stream = cp.cuda.get_current_stream()\\n\\n if buffer is None:\\n buffer = cp.asnumpy(binary)\\n else:\\n binary.get(out=buffer)\\n\\n if append is True:\\n mode = \\\"ab\\\"\\n else:\\n mode = \\\"wb\\\"\\n\\n with open(file, mode) as f:\\n stream.synchronize()\\n buffer.tofile(f)\",\n \"def write_cell(self, cell):\\n self._outfile.write(cell.to_gds(self._res))\\n return self\",\n \"def write_subactors_file_binary(filename, G, nodelist, profile, colnames):\\n assert(len(nodelist) == G.GetNodes())\\n assert(len(profile) >= G.GetNodes())\\n binattrs = ['gender', 'public']\\n # rename gender to male for binary attribute\\n binattr_names = ['male' if x == 'gender' else x for x in binattrs] \\n with open(filename, 'w') as f:\\n f.write(' '.join(binattr_names) + '\\\\n')\\n for i in nodelist:\\n for attr in binattrs:\\n val = profile[i][colnames[attr]]\\n val = val if val in ['0','1'] else 'NA'\\n f.write(val)\\n if attr == binattrs[-1]:\\n f.write('\\\\n')\\n else:\\n f.write(' ' )\",\n \"def write_file(self):\\n print 'Writing '+self.name+' binary...'\\n if self.vals is not None:\\n if len(self.vals) == self.size:\\n stream = self.pack_mem()\\n with open(self.name+'.bin','wb') as f:\\n f.write(stream)\\n print 'File written: '+self.name+'.bin'\\n else:\\n print 'Error: input array for '+self.name+'is not the right '+\\\\\\n 'size (should be '+str(self.size)+'). Skipping.'\\n else:\\n print 'No array provided, skipping.'\",\n \"def tabser(filename, body, data):\\n # XXX checksums ignored\\n head = Struct(\\\"!BiHBxxxB\\\")\\n body = Struct(body)\\n # foot = Struct(\\\"!4s\\\")\\n\\n buffer = bytearray([0] * (2 ** 16))\\n head.pack_into(buffer, 0, 0, int(time()), len(data), body.size, 0),\\n offset = head.size\\n for row in data:\\n body.pack_into(buffer, offset, *row, 0)\\n offset += body.size\\n else:\\n print(\\\"write %d rows\\\" % len(data))\\n # offset = 2 ** 16 - foot.size\\n # foot.pack_into(buffer, offset, bytes([0, 0, 0, 0]))\\n with open(filename, \\\"wb\\\") as f:\\n f.write(buffer)\",\n \"def write_gds(self, outfile, cells=None, timestamp=None):\\n if isinstance(outfile, basestring):\\n outfile = open(outfile, 'wb')\\n close = True\\n else:\\n close = False\\n now = datetime.datetime.today() if timestamp is None else timestamp\\n name = self.name if len(self.name) % 2 == 0 else (self.name + '\\\\0')\\n outfile.write(\\n struct.pack('>19h', 6, 0x0002, 0x0258, 28, 0x0102, now.year,\\n now.month, now.day, now.hour, now.minute, now.second,\\n now.year, now.month, now.day, now.hour, now.minute,\\n now.second, 4 + len(name), 0x0206) +\\n name.encode('ascii') + struct.pack('>2h', 20, 0x0305) +\\n _eight_byte_real(self.precision / self.unit) +\\n _eight_byte_real(self.precision))\\n if cells is None:\\n cells = self.cell_dict.values()\\n else:\\n cells = [self.cell_dict.get(c, c) for c in cells]\\n for cell in cells:\\n outfile.write(cell.to_gds(self.unit / self.precision))\\n outfile.write(struct.pack('>2h', 4, 0x0400))\\n if close:\\n outfile.close()\",\n \"def save_bin(data, file_path):\\n np.save(file_path, data)\",\n \"def _save_binary(file_name, data):\\n with open(file_name, \\\"wb\\\") as f:\\n cp.dump(data, f)\",\n \"def write_matrix_to_binary(file_name, val):\\n with open(file_name, 'wb') as file:\\n nrow = val.shape[0]\\n ncol = val.shape[1]\\n file.write(int32_to_bytes(nrow) + int32_to_bytes(ncol) + val.astype(float).tobytes(order='C'))\",\n \"def write_cells_shp(self,shpname,extra_fields=[],overwrite=True):\\n # assemble a numpy struct array with all of the info \\n # seems that having an object references in there is unstable,\\n # so pass geometries in a list separately.\\n base_dtype =[('poly_id1',np.int32),\\n ('area',np.float64),\\n ('volume',np.float64),\\n ('depth_mean',np.float64)]\\n\\n try:\\n cell_depths_max = self.cell_depths_max()\\n extra_fields.append( ('depth_max',np.float64, lambda i: cell_depths_max[i]) )\\n except:\\n pass\\n\\n for efi in range(len(extra_fields)):\\n fname,fdata=extra_fields[efi]\\n base_dtype.append( (fname,fdata.dtype) )\\n\\n cell_data = np.zeros(self.Ncells(), dtype=base_dtype)\\n\\n for efi in range(len(extra_fields)):\\n fname,fdata=extra_fields[efi]\\n cell_data[fname]=fdata\\n\\n self.update_cell_edges()\\n\\n cell_geoms = [None]*self.Ncells()\\n \\n cell_data['depth_mean'] = self.cell_depths()\\n cell_data['area']=self.cells_area()\\n cell_data['volume']=cell_data['depth_mean']*cell_data['area']\\n cell_data['poly_id1'] = 1+np.arange(self.Ncells())\\n\\n for poly_id in range(self.Ncells()):\\n if poly_id % 500 == 0:\\n print( \\\"%0.2g%%\\\"%(100.*poly_id/self.Ncells()) )\\n\\n # older code put this together manually.\\n cell_geoms[poly_id]=self.cell_polygon(poly_id)\\n\\n print( cell_data.dtype )\\n wkb2shp.wkb2shp(shpname,input_wkbs=cell_geoms,fields=cell_data,\\n overwrite=overwrite)\",\n \"def save_bin(words,data,fname):\\n\\n out=open(fname,\\\"wb\\\")\\n\\n rows,dims=data.shape\\n out.write(\\\"{} {}\\\\n\\\".format(rows,dims).encode(\\\"utf-8\\\"))\\n counter=0\\n\\n for i,w in enumerate(words):\\n out.write(w.encode(\\\"utf-8\\\"))\\n out.write(\\\" \\\".encode(\\\"utf-8\\\"))\\n out.write(struct.pack(\\\"{}f\\\".format(dims),*data[i,:]))\\n counter+=1\\n \\n out.close()\\n print(\\\"Model saved to\\\",fname,file=sys.stderr)\",\n \"def binary_write(iring, file_ext='out', *args, **kwargs):\\n return BinaryFileWriteBlock(iring, file_ext, *args, **kwargs)\",\n \"def save_fits(data, fname):\\n\\tcols = fits.ColDefs(np.copy(data)) # This is somehow necessary.\\n\\ttbhdu = fits.BinTableHDU.from_columns(cols)\\n\\ttbhdu.writeto(fname, clobber=True)\\n\\t\\n\\treturn\",\n \"def write_binary(self, data, ensure=False):\\n if ensure:\\n self.dirpath().ensure(dir=1)\\n with self.open(\\\"wb\\\") as f:\\n f.write(data)\",\n \"def writeCell(hoja, fila, columna, dato, formato=''):\\r\\n if formato:\\r\\n hoja.write(fila, columna, dato, formato)\\r\\n else:\\r\\n hoja.write(fila, columna, dato)\",\n \"def save_to(self, f: BinaryIO):\\n raise NotImplementedError\",\n \"def write(filename, data, extname=None, extver=None, header=None,\\n clobber=False, ignore_empty=False, units=None, table_type='binary',\\n names=None, write_bitcols=False, compress=None, tile_dims=None,\\n **keys):\\n if keys:\\n import warnings\\n warnings.warn(\\n \\\"The keyword arguments '%s' are being ignored! This warning \\\"\\n \\\"will be an error in a future version of `fitsio`!\\\" % keys,\\n DeprecationWarning, stacklevel=2)\\n\\n kwargs = {\\n 'clobber': clobber,\\n 'ignore_empty': ignore_empty\\n }\\n with FITS(filename, 'rw', **kwargs) as fits:\\n fits.write(data,\\n table_type=table_type,\\n units=units,\\n extname=extname,\\n extver=extver,\\n compress=compress,\\n header=header,\\n names=names,\\n write_bitcols=write_bitcols,\\n tile_dims=tile_dims)\",\n \"def write_file(self):\\r\\n # -open file for writing\\r\\n f_fbob = open(self.fn_path, 'w')\\r\\n\\r\\n # -write header\\r\\n f_fbob.write('%s\\\\n' % (self.heading))\\r\\n\\r\\n # -write sections 1 & 2 : NOTE- what about NOPRINT?\\r\\n f_fbob.write('%10i%10i%10i%10i\\\\n' % (self.nqfb, self.nqcfb,\\r\\n self.nqtfb, self.iufbobsv))\\r\\n f_fbob.write('%10e\\\\n' % (self.tomultfb)) # check format\\r\\n\\r\\n # -write sections 3-5 looping through observations groups\\r\\n c = 0\\r\\n for i in range(self.nqfb):\\r\\n # while (i < self.nqfb):\\r\\n # write section 3\\r\\n f_fbob.write('{:10d}{:10d}\\\\n'.format(self.nqobfb[i],\\r\\n self.nqclfb[i]))\\r\\n\\r\\n # Loop through observation times for the groups\\r\\n for j in range(self.nqobfb[i]):\\r\\n # -write section 4\\r\\n f_fbob.write(\\r\\n '{}{:10d}{:10.4g}{}{:10.4g}\\\\n'.format(self.obsnam[c],\\r\\n self.irefsp[c],\\r\\n self.toffset[c], ' ',\\r\\n self.flwobs[c]))\\r\\n c += 1 # index variable\\r\\n\\r\\n # -write section 5 - NOTE- need to adjust factor for muliple obs same cell\\r\\n for j in range(abs(self.nqclfb[i])):\\r\\n if self.nqclfb[\\r\\n i] < 0: # set factor to 1.0 for all cells in group\\r\\n self.factor[i, :] = 1.0\\r\\n f_fbob.write('{:10d}{:10d}{:10d}{}{:10f}\\\\n'\\r\\n .format(self.layer[i, j], (self.row[i, j]),\\r\\n self.column[i, j],\\r\\n ' ', self.factor[\\r\\n i, j])) # note- is 10f good enough here?\\r\\n\\r\\n f_fbob.close()\\r\\n #\\r\\n # swm: BEGIN hack for writing standard file\\r\\n sfname = self.fn_path # swm:hack\\r\\n sfname += '_ins' # swm: hack\\r\\n # write header\\r\\n f_ins = open(sfname, 'w') # swm: hack for standard file\\r\\n f_ins.write('jif @\\\\n') # swm: hack for standard file\\r\\n f_ins.write('StandardFile 0 1 %s\\\\n' % (\\r\\n self.nqtfb)) # swm: hack for standard file\\r\\n for i in range(0, self.nqtfb):\\r\\n f_ins.write(\\r\\n '{}\\\\n'.format(self.obsnam[i])) # swm: hack for standard file\\r\\n\\r\\n f_ins.close()\\r\\n # swm: END hack for writing standard file\\r\\n\\r\\n return\",\n \"def write(self, fileW):\\n fileW.wByte(self.b)\\n fileW.wByte(self.g)\\n fileW.wByte(self.r)\\n fileW.wByte(self.a)\",\n \"def write(self, data, units=None, extname=None, extver=None,\\n compress=None, tile_dims=None, header=None, names=None,\\n table_type='binary', write_bitcols=False, **keys):\\n\\n if keys:\\n import warnings\\n warnings.warn(\\n \\\"The keyword arguments '%s' are being ignored! This warning \\\"\\n \\\"will be an error in a future version of `fitsio`!\\\" % keys,\\n DeprecationWarning, stacklevel=2)\\n\\n isimage = False\\n if data is None:\\n isimage = True\\n elif isinstance(data, numpy.ndarray):\\n if data.dtype.fields == None: # noqa - probably should be is None\\n isimage = True\\n\\n if isimage:\\n self.write_image(data, extname=extname, extver=extver,\\n compress=compress, tile_dims=tile_dims,\\n header=header)\\n else:\\n self.write_table(data, units=units,\\n extname=extname, extver=extver, header=header,\\n names=names,\\n table_type=table_type,\\n write_bitcols=write_bitcols)\",\n \"def writeElems(fil, elems1, eofs=1, nofs=1):\\n #pyFormex uses the same convention for hexahedral elements as ABAQUS\\n #Gambit uses a different convention\\n #function currently only for hexahedral mesh\\n elems = elems1.copy()\\n elems[:,2] = elems1[:,3]\\n elems[:,3] = elems1[:,2]\\n\\n elems[:,6] = elems1[:,7]\\n elems[:,7] = elems1[:,6]\\n \\n fil.write(' ELEMENTS/CELLS 2.2.30\\\\n')\\n for i,e in enumerate(elems+nofs):\\n fil.write('%8d %2d %2d %8d%8d%8d%8d%8d%8d%8d\\\\n %8d\\\\n' % ((i+eofs,4,8)+tuple(e)))\\n fil.write('ENDOFSECTION\\\\n')\",\n \"def write_file(file_name, table):\\r\\n \\r\\n savectr=len(table)\\r\\n try:\\r\\n with open (file_name, 'wb') as objFile:\\r\\n pickle.dump(table,objFile) #pickle my 2D list\\r\\n print ('{} CD(s) saved into {}.\\\\n'.format(savectr,file_name))\\r\\n except PermissionError as e:\\r\\n print('Not enough rights to create/modify ' + file_name + '.') #if unable pickle data due to permission issues\\r\\n print ()\\r\\n print (e, e.__doc__, sep='\\\\n')\\r\\n print ()\\r\\n except IOError as e:\\r\\n print ('I/O error({0}): {1}'.format(e.errno,e.strerror))#if unable to pickle data due to IO errors such as disk space issues\\r\\n print ()\\r\\n print (e, e.__doc__, sep='\\\\n')\\r\\n print ()\\r\\n except pickle.PickleError as e:\\r\\n print ('Unable to write data into ' + file_name + '.') #if unable to pickle 2D list, exception handling for pickling errors\\r\\n print ()\\r\\n print (e, e.__doc__, sep='\\\\n')\\r\\n print ()\",\n \"def _saveBinaryData(self, file, with_axis=None):\\n if with_axis is not None:\\n data = self._data_with_axis(with_axis)\\n numpy.save(file, data)\\n else:\\n numpy.save(file, self.data)\",\n \"def save(self,outPath=None):\\n if (not self.canSave or self.skipObjRecords): raise StateError(_(\\\"Insufficient data to write file.\\\"))\\n if not outPath:\\n fileInfo = self.fileInfo\\n outPath = os.path.join(fileInfo.dir,fileInfo.name)\\n out = file(outPath,'wb')\\n #--Tes3 Record\\n self.tes3.changed = 1\\n self.tes3.hedr.changed = 1\\n self.tes3.hedr.numRecords = len(self.records) #--numRecords AFTER TES3 record\\n self.tes3.getSize()\\n self.tes3.dump(out)\\n #--Size Cell Records\\n cntRecords = 0\\n progress = self.progress\\n progress.setMax(len(self.cells))\\n progress(0.0,'Saving '+self.fileInfo.name)\\n for record in self.cells:\\n record.getSize()\\n #--Progress\\n cntRecords += 1\\n progress(cntRecords)\\n #--Other Records\\n for record in self.records:\\n record.getSize() #--Should already be done, but just in case.\\n record.dump(out)\\n out.close()\",\n \"def write_raw_text(self, path='.'):\\n cells = self.get_cells()\\n arrays = []\\n for cell in cells:\\n arrays.append(cell.data)\\n array = np.concatenate(arrays)\\n fn = os.path.join(path, self.label + '.txt')\\n fmt = []\\n p = re.compile('(\\\\w)(\\\\d+)')\\n for key, value in self.datatype:\\n m = p.search(value)\\n if m:\\n kind, size = m.groups()\\n # strings\\n if kind == 'S':\\n add = '%{}c'.format(size)\\n # integers\\n elif kind in ['u', 'i']:\\n add = '%d'\\n else:\\n add = '%.8e'\\n else:\\n add = '%.8e'\\n fmt.append(add)\\n np.savetxt(fn, array, fmt=fmt, delimiter='\\\\t')\\n return\",\n \"def save_scan_on_file(self,branch=1):\\n if branch==1:\\n np.save(file=self.scan_path_T,arr=self.thr_scan_matrix)\\n else:\\n np.save(file=self.scan_path_E, arr=self.thr_scan_matrix)\\n # if branch==1:\\n # f = open(self.scan_path_T, 'w')\\n # else:\\n # f = open(self.scan_path_E, 'w')\\n #\\n # for T in range(0, 8):\\n # f.write(\\\"Tiger {}\\\".format(T))\\n # f.write(\\\"Frames\\\\n\\\")\\n # for i in range(0, 64):\\n # f.write(\\\"\\\\nChannel {}\\\\n\\\".format(i))\\n #\\n # for j in range (0,64):\\n # if self.thr_scan_frames[T, i, j]:\\n # f.write(\\\"{},\\\".format(self.thr_scan_frames[T, i, j]))\\n # else:\\n # f.write(\\\"0,\\\")\\n #\\n # f.write(\\\"\\\\nEvents\\\\n\\\")\\n # for i in range(0, 64):\\n # f.write(\\\"\\\\nChannel {}\\\\n\\\".format(i))\\n #\\n # for j in range (0,64):\\n # if self.thr_scan_frames[T, i, j]:\\n # f.write(\\\"{},\\\".format(self.thr_scan_matrix[T, i, j]))\\n # else:\\n # f.write(\\\"0,\\\")\\n # f.write(\\\"\\\\n\\\")\\n #\\n # f.close()\",\n \"def write_cell(self, cell, timestamp=None):\\n cell.to_gds(self._outfile, self._res, timestamp)\\n return self\",\n \"def writebytes(self, *args) -> \\\"int\\\":\\n return _ida_fpro.qfile_t_writebytes(self, *args)\",\n \"def depth_write(filename, depth):\\n height,width = depth.shape[:2]\\n f = open(filename,'wb')\\n # write the header\\n f.write(TAG_CHAR)\\n np.array(width).astype(np.int32).tofile(f)\\n np.array(height).astype(np.int32).tofile(f)\\n \\n depth.astype(np.float32).tofile(f)\\n f.close()\",\n \"def write (self, file):\\n\\t\\tfile.write (self.pack ())\",\n \"def write_to_file(fib_details: dict):\\n pass # TODO: Replace with implementation!\",\n \"def save_GRID( self , filename ):\\n self._fwrite_GRID( filename )\",\n \"def write(self, binary_log: BinaryLoggable) -> None:\\n if binary_log == None:\\n return #possibly raise exception\\n record_array = binary_log.to_bytes()\\n record_len = len(record_array)\\n if record_len == 0:\\n return #possibly raise exception\\n\\n log_name = type(binary_log).__name__\\n self.file_map.setdefault(log_name, [])\\n\\n # Writes log_name size and log_name to the end of file\\n self.bfile.seek(0,os.SEEK_END)\\n self.bfile.write(len(log_name).to_bytes(self.IntLength, byteorder='big'))\\n self.bfile.write(bytearray(log_name, self.Encoding))\\n\\n # Write byte_array size and byte array\\n self.bfile.write(record_len.to_bytes(self.IntLength, byteorder='big'))\\n self.file_map[log_name].append([self.bfile.tell(),record_len])\\n self.bfile.write(record_array)\",\n \"def export_cell_budget(cell_budget_file, grid,\\n binary_grid_file=None,\\n kstpkper=None, text=None, idx=0,\\n precision='single',\\n output_path='postproc', suffix=''):\\n print('Exporting cell budget info...')\\n print('file: {}'.format(cell_budget_file))\\n print('binary grid file: {}'.format(binary_grid_file))\\n\\n cbbobj = bf.CellBudgetFile(cell_budget_file, precision=precision)\\n if kstpkper is None:\\n kstpkper = cbbobj.get_times()[idx]\\n if np.isscalar(kstpkper[0]):\\n kstpkper = [kstpkper]\\n\\n pdfs_dir, rasters_dir, shps_dir = make_output_folders(output_path)\\n if text is not None and not isinstance(text, list):\\n text = [text]\\n\\n names = [r.decode().strip() for r in cbbobj.get_unique_record_names()]\\n if text is not None:\\n names = list(set(text).intersection(names))\\n if len(names) == 0:\\n print('{} not found in {}'.format(' '.join(text), cell_budget_file))\\n\\n outfiles = []\\n for kstp, kper in kstpkper:\\n print('stress period {}, timestep {}'.format(kper, kstp))\\n for variable in names:\\n if variable == 'FLOW-JA-FACE':\\n df = get_flowja_face(cbbobj, binary_grid_file=binary_grid_file,\\n kstpkper=(kstp, kper), idx=idx,\\n precision=precision)\\n # export the vertical fluxes as rasters\\n # (in the downward direction; so fluxes between 2 layers\\n # would be represented in the upper layer)\\n if df is not None and 'kn' in df.columns and np.any(df['kn'] < df['km']):\\n vflux = df.loc[(df['kn'] < df['km'])]\\n nlay = vflux['km'].max()\\n _, nrow, ncol = grid.shape\\n vflux_array = np.zeros((nlay, nrow, ncol))\\n vflux_array[vflux['kn'].values,\\n vflux['in'].values,\\n vflux['jn'].values] = vflux.q.values\\n data = vflux_array\\n else:\\n data = get_bc_flux(cbbobj, variable, kstpkper=(kstp, kper), idx=idx)\\n if data is None:\\n print('{} not exported.'.format(variable))\\n continue\\n outfile = '{}/{}_per{}_stp{}{}.tif'.format(rasters_dir, variable, kper, kstp, suffix)\\n export_array(outfile, data, grid, nodata=0)\\n outfiles.append(outfile)\\n return outfiles\",\n \"def Write(self):\\n table_data = self._TABLE.build(self._offsets)\\n self._zip_file.writestr(self._stream_name, table_data)\",\n \"def write(self, filename):\\n f = open(filename, 'bw')\\n\\n # file header (14)\\n f.write(char('B'))\\n f.write(char('M'))\\n f.write(dword(14 + 40 + self.width * self.height * 3))\\n f.write(dword(0))\\n f.write(dword(14 + 40))\\n\\n # image header (40)\\n f.write(dword(40))\\n f.write(dword(self.width))\\n f.write(dword(self.height))\\n f.write(word(1))\\n f.write(word(24))\\n f.write(dword(0))\\n f.write(dword(0))\\n f.write(dword(self.width * self.height * 3))\\n f.write(dword(0))\\n f.write(dword(0))\\n f.write(dword(0))\\n f.write(dword(0))\\n\\n # pixel data\\n for x in range(self.height):\\n for y in range(self.width):\\n f.write(self.pixels[x][y])\\n f.close()\",\n \"def write_CASTEP_cell(CASTEP_cell,filename):\\n f=open(seedname+\\\".cell\\\",\\\"r\\\")\\n castep_cell = f.readlines()\\n global hashes\\n f=StringIO.StringIO()\\n f.write(\\\"%BLOCK LATTICE_CART\\\\n\\\")\\n for i in xrange(3):\\n f.write(\\\"{0[0]:>20.15f} {0[1]:>20.15f} {0[2]:>20.15f}\\\\n\\\".format(\\n (CASTEP_cell[\\\"lattvec\\\"][:,i]*10).tolist()))\\n f.write(\\\"%ENDBLOCK LATTICE_CART\\\\n\\\")\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"%BLOCK POSITIONS_FRAC\\\\n\\\")\\n k = 0\\n for i in xrange(len(CASTEP_cell[\\\"numbers\\\"])):\\n for j in xrange(CASTEP_cell[\\\"numbers\\\"][i]):\\n l = k + j\\n f.write(\\\"{0}\\\".format(\\\"\\\".join(CASTEP_cell[\\\"elements\\\"][i]))) \\n f.write(\\\"{0[0]:>20.15f} {0[1]:>20.15f} {0[2]:>20.15f}\\\\n\\\".format(\\n CASTEP_cell[\\\"positions\\\"][:,l].tolist()))\\n k += j + 1\\n f.write(\\\"%ENDBLOCK POSITIONS_FRAC\\\\n\\\")\\n\\n # Copy everything after '%ENDBLOCK POSITIONS_FRAC'\\n for index, line in enumerate(castep_cell):\\n if '%ENDBLOCK POSITIONS_FRAC' in line.upper():\\n index_end = index\\n for i in xrange(index_end+1,len(castep_cell)):\\n f.write(castep_cell[i])\\n with open(filename,\\\"w\\\") as finalf:\\n finalf.write(f.getvalue())\\n f.close()\",\n \"def write_record(self, *items):\\n items = tuple(np.asarray(item) for item in items)\\n total_size = sum(item.nbytes for item in items)\\n\\n nb = np.array([total_size], dtype=self._header_dtype)\\n\\n nb.tofile(self._fp)\\n for item in items:\\n item.tofile(self._fp)\\n nb.tofile(self._fp)\",\n \"def _write(self):\\n f = FortranFile(self.filename,mode='w')\\n # Default omnivor binary header\\n f.writeInts ( self.data['MK'] , 'i' ) \\n f.writeInts ( self.data['itime'] , 'i' ) \\n f.writeString ( self.data['version'] ) \\n f.writeInts ( self.data['file_id'] , 'i' ) \\n f.writeString ( self.data['sversion'] ) \\n # Velocity field\\n f.writeString ( self.data['stype'] ) \\n f.writeInts ( self.data['is_grid'] , 'i' ) \\n f.writeInts ( self.data['nCPs'] , 'i' ) \\n if self.data['MK'] == 8:\\n real_char='d'\\n else:\\n real_char='f'\\n if self.data['is_grid']:\\n f.writeInts ( self.data['n1'] , 'i' ) \\n f.writeInts ( self.data['n2'] , 'i' ) \\n f.writeInts ( self.data['n3'] , 'i' ) \\n f.writeInts ( self.data['is_straight'] , 'i' ) \\n f.writeReals ( self.data['v1'] , real_char ) \\n f.writeReals ( self.data['v2'] , real_char ) \\n f.writeReals ( self.data['v3'] , real_char ) \\n\\n CPs = self.data['CPs'].flatten(order = 'F')\\n Utot = self.data['Utot'].flatten(order = 'F')\\n f.writeReals(CPs,real_char)\\n f.writeReals(Utot,real_char)\",\n \"def write_file(_data, _label, _clinical, _contour, _type):\\n pickle.dump(np.array(_data), open(_type + '_data.pxl', 'wb'))\\n pickle.dump(np.array(_label), open(_type + '_label.pxl', 'wb'))\\n pickle.dump(np.array(_clinical), open(_type + '_clinical.pxl', 'wb'))\\n pickle.dump(np.array(_contour), open(_type + '_contour.pxl', 'wb'))\",\n \"def write_data(self, filename,\\n columns=('Q', 'R', 'dR'),\\n header=None):\\n if header is None:\\n header = \\\"# %s\\\\n\\\"%' '.join(columns)\\n with open(filename, 'wb') as fid:\\n fid.write(asbytes(header))\\n data = np.vstack([getattr(self, c) for c in columns])\\n np.savetxt(fid, data.T)\",\n \"def _write(self, out_file):\\n out_file.write(' '.encode()) # pad byte\\n out_file.write('{:4d}'.format(self.key).encode())\\n out_file.write(self.code.encode())\\n out_file.write((' '*18).encode()) # pad bytes\\n out_file.write('{:12d}'.format(self.numnod).encode())\\n out_file.write((' '*37).encode()) # pad bytes\\n out_file.write('{:1d}'.format(self.format).encode())\\n out_file.write('\\\\n'.encode())\\n\\n for node in self.nodes:\\n if self.format < 2:\\n out_file.write(' '.encode())\\n out_file.write('-1'.encode())\\n if self.format == 0:\\n out_file.write('{:5d}'.format(node.number).encode())\\n else:\\n out_file.write('{:10d}'.format(node.number).encode())\\n for i in range(3):\\n out_file.write('{:12.5E}'.format(node.pos[i]).encode())\\n out_file.write('\\\\n'.encode())\\n else:\\n out_file.write(struct.pack('i', node.number))\\n if self.format == 2:\\n out_file.write(struct.pack('fff', *node.pos))\\n else:\\n out_file.write(struct.pack('ddd', *node.pos))\\n\\n if self.format < 2:\\n out_file.write(' -3\\\\n'.encode()) # last record for ascii only\",\n \"def write(self, filename):\\n bvh_string = self.generate_bvh_string()\\n if filename[-4:] == '.bvh':\\n filename = filename\\n else:\\n filename = filename + '.bvh'\\n with open(filename, 'w') as outfile:\\n outfile.write(bvh_string)\",\n \"def write_to(self, filename):\\n with open(filename, 'w') as f:\\n for xx, yy, zz, ww in zip(self.x, self.y, self.field, self.weight):\\n f.write(\\\"%s %s %s %s\\\\n\\\" % (xx, yy, zz, ww))\\n logger.info(\\\"Written data into file {0}\\\".format(filename))\",\n \"def to_binary(inputs, outputs, filename_label=None):\\n inputs.write(filename_label, filename_label=filename_label)\\n outputs.write(filename_label, filename_label=filename_label)\",\n \"def save_to_file(grid, filepath):\\n outfile = codecs.open(filepath, mode='w+', encoding='utf-8')\\n outfile.writelines([((''.join(row)) + u'\\\\n') for row in grid])\",\n \"def test_write_bintable(self):\\n from ..io.util import write_bintable, fitsheader\\n #\\n # Input: Table\\n #\\n hdr = fitsheader(dict(A=1, B=2))\\n hdr['C'] = ('BLAT', 'FOO')\\n data = Table()\\n data['X'] = [1, 2, 3]\\n data['Y'] = [3, 4, 5]\\n write_bintable(self.testfile, data, header=hdr)\\n #\\n # Standard suite of table tests.\\n #\\n result, newhdr = fits.getdata(self.testfile, header=True)\\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\\n for colname in data.dtype.names:\\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\\n self.assertEqual(newhdr.comments['C'], 'FOO')\\n for key in hdr.keys():\\n self.assertIn(key, newhdr)\\n self.assertIn('DATASUM', newhdr)\\n self.assertIn('CHECKSUM', newhdr)\\n os.remove(self.testfile)\\n #\\n # Input: ndarray\\n #\\n hdr = dict(A=1, B=2)\\n data = data.as_array()\\n write_bintable(self.testfile, data, header=hdr)\\n #\\n # Standard suite of table tests.\\n #\\n result, newhdr = fits.getdata(self.testfile, header=True)\\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\\n for colname in data.dtype.names:\\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\\n # self.assertEqual(newhdr.comments['C'], 'FOO')\\n for key in hdr.keys():\\n self.assertIn(key, newhdr)\\n self.assertIn('DATASUM', newhdr)\\n self.assertIn('CHECKSUM', newhdr)\\n os.remove(self.testfile)\\n #\\n # Input: dictionary\\n #\\n hdr = dict(A=1, B=2)\\n d = dict(X=np.array([1, 2, 3]), Y=np.array([3, 4, 5]))\\n write_bintable(self.testfile, d, header=hdr)\\n #\\n # Standard suite of table tests.\\n #\\n result, newhdr = fits.getdata(self.testfile, header=True)\\n\\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\\n\\n for colname in data.dtype.names:\\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\\n # self.assertEqual(newhdr.comments['C'], 'FOO')\\n for key in hdr.keys():\\n self.assertIn(key, newhdr)\\n self.assertIn('DATASUM', newhdr)\\n self.assertIn('CHECKSUM', newhdr)\\n os.remove(self.testfile)\\n #\\n # Input: Table with column comments.\\n #\\n hdr = fitsheader(dict(A=1, B=2))\\n hdr['C'] = ('BLAT', 'FOO')\\n data = Table()\\n data['X'] = [1, 2, 3]\\n data['Y'] = [3, 4, 5]\\n write_bintable(self.testfile, data, header=hdr,\\n comments={'X': 'This is X', 'Y': 'This is Y'},\\n units={'X': 'mm', 'Y': 'mm'})\\n #\\n # Standard suite of table tests.\\n #\\n result, newhdr = fits.getdata(self.testfile, header=True)\\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\\n for colname in data.dtype.names:\\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\\n # self.assertEqual(newhdr.comments['C'], 'FOO')\\n for key in hdr.keys():\\n self.assertIn(key, newhdr)\\n self.assertIn('DATASUM', newhdr)\\n self.assertIn('CHECKSUM', newhdr)\\n self.assertEqual(newhdr['TTYPE1'], 'X')\\n self.assertEqual(newhdr.comments['TTYPE1'], 'This is X')\\n self.assertEqual(newhdr['TTYPE2'], 'Y')\\n self.assertEqual(newhdr.comments['TTYPE2'], 'This is Y')\\n self.assertEqual(newhdr['TUNIT1'], 'mm')\\n self.assertEqual(newhdr.comments['TUNIT1'], 'X units')\\n self.assertEqual(newhdr['TUNIT2'], 'mm')\\n self.assertEqual(newhdr.comments['TUNIT2'], 'Y units')\\n #\\n # Input: Table with no EXTNAME, existing file\\n #\\n write_bintable(self.testfile, data, header=hdr)\\n #\\n # Input: Table with EXTNAME, existing file\\n #\\n write_bintable(self.testfile, data, header=hdr, extname='FOOBAR')\\n #\\n # Standard suite of table tests.\\n #\\n result, newhdr = fits.getdata(self.testfile, header=True, extname='FOOBAR')\\n self.assertEqual(sorted(result.dtype.names), sorted(data.dtype.names))\\n for colname in data.dtype.names:\\n self.assertTrue(np.all(result[colname] == data[colname]), '{} data mismatch'.format(colname))\\n # self.assertEqual(newhdr.comments['C'], 'FOO')\\n for key in hdr.keys():\\n self.assertIn(key, newhdr)\\n self.assertIn('DATASUM', newhdr)\\n self.assertIn('CHECKSUM', newhdr)\\n #\\n # Input: Table with existing EXTNAME, existing file\\n #\\n write_bintable(self.testfile, data, header=hdr, extname='FOOBAR')\\n #\\n # Input: Table with EXTNAME, existing file, overwrite\\n #\\n write_bintable(self.testfile, data, header=hdr, extname='FOOBAR', clobber=True)\",\n \"def writecif(atoms, coords, filename, text=''):\\n \\n f = open(filename+'.cif', 'w')\\n f.write(text)\\n \\n for atom, coord in zip(atoms, coords):\\n f.write(\\\"{} {} {} {}\\\\n\\\".format(atom, coord[0], coord[1], coord[2]))\\n \\n f.close()\",\n \"def write_body(filepath, *coords):\\n with open(filepath, 'w') as outfile:\\n outfile.write('{}\\\\n'.format(len(coords[0])))\\n with open(filepath, 'ab') as outfile:\\n numpy.savetxt(outfile, numpy.c_[coords])\",\n \"def save(self, file):\\n boulders = []\\n elephants = []\\n rhinos = []\\n for i in range(5):\\n for j in range(5):\\n if self[i][j]!= 0:\\n piece = self[i][j]\\n L = []\\n if not isinstance(self[i][j], Boulder):\\n L.append(self[i][j].direction[0])\\n L.append(self[i][j].direction[1])\\n if piece.species == \\\"Elephant\\\":\\n elephants.append(\\\"(\\\" + str(i) + \\\",\\\" + str(j)+ \\\") : np.array([\\\"+str(L[0])+ \\\",\\\" + str(L[1])+\\\"])\\\")\\n elif piece.species == \\\"Rhinoceros\\\":\\n rhinos.append(\\\"(\\\"+str(i)+\\\",\\\" +str(j)+ \\\") : np.array([\\\"+str(L[0]) + \\\",\\\" + str(L[1])+\\\"])\\\")\\n elif isinstance(piece, Boulder):\\n boulders.append(\\\"(\\\" + str(i) + \\\",\\\" + str(j) + \\\")\\\")\\n file.write(\\\"# King of Siam GameFile \\\\n\\\\nplayer_turn {\\\\n \\\" + self.playerTurn + \\\"\\\\n}\\\\n\\\\n\\\")\\n file.write(\\\"Boulder {\\\")\\n for k in range(len(boulders)):\\n file.write(\\\"\\\\n \\\" + boulders[k] + \\\";\\\")\\n file.write(\\\"\\\\n}\\\\n\\\\nElephant {\\\")\\n for elt in elephants:\\n file.write(\\\"\\\\n \\\" + elt + \\\";\\\")\\n file.write(\\\"\\\\n}\\\\n\\\\nRhinoceros {\\\")\\n for elt in rhinos:\\n file.write(\\\"\\\\n \\\" + elt + \\\";\\\")\\n file.write(\\\"\\\\n}\\\")\\n\\n file.close()\",\n \"def write(self, row):\\n bytes = struct.pack(self.pack_format, *row)\\n self.f.write(bytes)\",\n \"def write_flow(flow, filename):\\n f = open(filename, 'wb')\\n magic = np.array([202021.25], dtype=np.float32)\\n (height, width) = flow.shape[0:2]\\n w = np.array([width], dtype=np.int32)\\n h = np.array([height], dtype=np.int32)\\n magic.tofile(f)\\n w.tofile(f)\\n h.tofile(f)\\n flow.tofile(f)\\n f.close()\",\n \"def _writeWaveform(self, fo, header='', binary=False):\\n # TODO: Write channel data to file\\n pass\",\n \"def write( self, NewFilename='', Integer=True ):\\n try:\\n if NewFilename != '':\\n self.name=NewFilename\\n Output = open( self.name, 'w' )\\n Output.write( 'ncols\\\\t\\\\t %d\\\\n' % self.ncols )\\n Output.write( 'nrows\\\\t\\\\t %d\\\\n' % self.nrows )\\n Output.write( 'xllcorner\\\\t\\\\t %f\\\\n' % self.xllcorner)\\n Output.write( 'yllcorner\\\\t\\\\t %f\\\\n' % self.yllcorner)\\n Output.write( 'cellsize\\\\t\\\\t %f\\\\n' % self.cellsize)\\n if Integer:\\n Output.write( 'NODATA_value\\\\t\\\\t %d\\\\n' % int(self.nodata) )\\n else:\\n Output.write( 'NODATA_value\\\\t\\\\t %f\\\\n' % self.nodata )\\n for row in range( self.nrows-1,-1,-1 ):\\n record = []\\n for col in range( self.ncols ):\\n if Integer:\\n record.append( str( int( round( self.data[row,col]) ) ) )\\n else:\\n record.append( str(self.data[row,col]) )\\n Output.write( string.join(record, ' ')+'\\\\n' )\\n Output.close()\\n except:\\n print \\\"Error writing grid ::\\\", self.name\",\n \"def write_flow(flow, filename):\\n f = open(filename, 'wb')\\n magic = numpy.array([202021.25], dtype=numpy.float32)\\n (height, width) = flow.shape[0:2]\\n w = numpy.array([width], dtype=numpy.int32)\\n h = numpy.array([height], dtype=numpy.int32)\\n magic.tofile(f)\\n w.tofile(f)\\n h.tofile(f)\\n flow.tofile(f)\\n f.close()\",\n \"def write(self, fname):\\n pass\",\n \"def write(self, filename, **kwargs):\\n self.to_table().write(filename, format='fits', **kwargs)\",\n \"def test_file_bin_readwrite(self):\\n FileWriter(self.binary_path).write_bin(self.binary_string)\\n bin_data = FileReader(self.binary_path).read_bin()\\n self.assertEqual(bin_data, self.binary_string)\",\n \"def write_table(table, file_path):\\n\\n\\twith open(file_path, 'w') as file:\\n\\t\\tfile.write(table)\",\n \"def write_ptm_gridfile(self,fn):\\n vertex_hdr = \\\" Vertex Data: vertex_number, x, y\\\"\\n poly_hdr = \\\" Polygon Data: polygon_number, number_of_sides,center_x, center_y, center_depth, side_indices(number_of_sides), marker(0=internal,1=open boundary)\\\"\\n side_hdr = \\\" Side Data: side_number, side_depth, node_indices(2), cell_indices(2), marker(0=internal,1=external,2=flow boundary,3=open boundary)\\\"\\n\\n with open(fn,'wt') as fp:\\n # write header counts\\n fp.write(\\\" Number of Vertices\\\\n\\\")\\n fp.write(\\\" %20d\\\\n\\\"%self.Nnodes())\\n fp.write(\\\" Number of Polygons\\\\n\\\")\\n fp.write(\\\" %20d\\\\n\\\"%self.Ncells())\\n fp.write(\\\" Number of Sides\\\\n\\\")\\n fp.write(\\\" %20d\\\\n\\\"%self.Nedges())\\n fp.write(\\\" NODATA (land) value\\\\n\\\")\\n fp.write(\\\" -9999.000000000\\\\n\\\")\\n\\n # write vertex info\\n fp.write(vertex_hdr+\\\"\\\\n\\\")\\n for v in range(self.Nnodes()):\\n fp.write(\\\" %10d %16.7f %16.7f\\\\n\\\"%(v+1,\\n self.nodes['x'][v,0],\\n self.nodes['x'][v,1]))\\n\\n # write polygon info\\n fp.write(poly_hdr+\\\"\\\\n\\\")\\n cell_write_str1 = \\\" %10d %10d %16.7f %16.7f %16.7f \\\"\\n cell_depths = self.cell_depths()\\n for e in range(self.Ncells()):\\n edges = self.cells['edges'][e,:]\\n edges[edges<0] = -1\\n edge_str = \\\" \\\".join( [\\\"%10d\\\"%(s+1) for s in edges] )\\n edge_str = edge_str+\\\" %10d\\\\n\\\"%(self.cells['mark'][e])\\n nsides = sum(edges>=0)\\n fp.write(cell_write_str1%(e+1,\\n nsides,\\n self.cells['_center'][e,0],\\n self.cells['_center'][e,1],\\n cell_depths[e]))\\n fp.write(edge_str)\\n \\n # write side info\\n fp.write(side_hdr+\\\"\\\\n\\\")\\n edge_depths = self.edge_depths()\\n edge_write_str = \\\" %10d %16.7f %10d %10d %10d %10d %10d\\\\n\\\"\\n for s in range(self.Nedges()):\\n edges = self.edges['cells'][s,:]\\n edges[edges<0] = -1 \\n nodes = self.edges['nodes'][s,:]\\n nodes[nodes<0] = -1\\n fp.write(edge_write_str%(s+1,\\n edge_depths[s],\\n nodes[0]+1,\\n nodes[1]+1,\\n edges[0]+1,\\n edges[1]+1,\\n self.edges['mark'][s]))\",\n \"def write(self, file, endian=None):\\n if endian is None:\\n endian = self.endian\\n for item in BINARY_FILE_HEADER_FORMAT:\\n length, name, _ = item\\n # Unpack according to different lengths.\\n if length == 2:\\n format = ('%sh' % endian).encode('ascii', 'strict')\\n # Write to file.\\n file.write(pack(format, getattr(self, name)))\\n # Update: Seems to be correct. Two's complement integers seem to be\\n # the common way to store integer values.\\n elif length == 4:\\n format = ('%si' % endian).encode('ascii', 'strict')\\n # Write to file.\\n file.write(pack(format, getattr(self, name)))\\n # These are the two unassigned values in the binary file header.\\n elif name.startswith('unassigned'):\\n temp = getattr(self, name)\\n if not isinstance(temp, bytes):\\n temp = str(temp).encode('ascii', 'strict')\\n temp_length = len(temp)\\n # Pad to desired length if necessary.\\n if temp_length != length:\\n temp += b'\\\\x00' * (length - temp_length)\\n file.write(temp)\\n # Should not happen.\\n else:\\n raise Exception\",\n \"def testWriteBinaryData(self):\\n file_writer = writers.FileWriter()\\n\\n file_writer._file = io.BytesIO()\\n\\n file_writer.WriteBinaryData(b'Binary data')\\n\\n file_writer._file.seek(0, os.SEEK_SET)\\n output_data = file_writer._file.read()\\n expected_output_data = b'Binary data'\\n self.assertEqual(output_data, expected_output_data)\",\n \"def write_bi_code_to_file(bi_code, file_path):\\r\\n with open(file_path, 'w') as file:\\r\\n for i in bi_code:\\r\\n file.write(f'{i}\\\\n')\",\n \"def write_checkpoint(self):\\n self.file_checkpoint_data = open(self.path_checkpoint, \\\"a+\\\")\\n array_to_write = [str(self.radious), self.type_feature, self.type_filtering, self.h_filterig]\\n self.file_checkpoint_data.write(','.join(array_to_write) + \\\"\\\\n\\\")\\n self.file_checkpoint_data.flush()\",\n \"def write_grid2d(grid_file, grid2d):\\n with grid_file.open('w') as f:\\n for row in grid2d['label']:\\n f.write('\\\\t'.join(row) + '\\\\n')\",\n \"def write_bin(raw):\\n a = raw.astype('i1')\\n b = a.reshape((-1,2))\\n\\n b[:,1] = b[:,1] << 4\\n\\n c = np.bitwise_or(b[:,0], b[:,1]).astype('i1')\\n\\n return c\",\n \"def write_to_file(self, filename):\\n self.octree.write(str.encode(filename))\\n print(\\\"Save octomap to \\\"+filename)\",\n \"def add_cells(self):\\n # To delete all common cells\\n self.delete_cells()\\n if self.removed_last_bracket:\\n new_lib = self.base_doc + self.cell_doc + '\\\\n}\\\\n'\\n else:\\n end_part = self.base_doc[-4:] \\n if '}' in end_part:\\n new_lib = self.base_doc[0:-4] + '\\\\n\\\\t\\\\t' + self.cell_doc + '\\\\n}\\\\n'\\n # print(new_lib)\\n try: \\n with open(self.output_file, \\\"w\\\") as file_doc:\\n file_doc.write(new_lib)\\n return True\\n except:\\n return False\",\n \"def write_bed_file(bed_dict, out_file_name):\\n with open(os.getcwd() + '/' + ntpath.basename(out_file_name), 'w') as out_file:\\n for header in bed_dict.keys():\\n for coordinates in bed_dict[header]:\\n out_file.write(\\n '%s\\\\t%r\\\\t%r\\\\n' %(header[1:], coordinates[0], coordinates[1])\\n )\",\n \"def write_to_file(board, output_file = \\\"solution.sud\\\"):\\n with open(output_file, \\\"w\\\") as f:\\n for i in range(n):\\n if i and i%3==0:\\n f.write(\\\"------+-------+------\\\\n\\\")\\n for j in range(n): \\n if j and j%3==0:\\n f.write(\\\"| \\\")\\n if len(board[i][j]) == 1:\\n f.write(str(board[i][j][0]) + \\\" \\\")\\n else:\\n f.write(\\\". \\\")\\n elif j==8:\\n if len(board[i][j]) == 1:\\n f.write(str(board[i][j][0]) + \\\"\\\\n\\\")\\n else:\\n f.write(\\\".\\\\n\\\")\\n else:\\n if len(board[i][j]) == 1:\\n f.write(str(board[i][j][0]) + \\\" \\\")\\n else:\\n f.write(\\\". \\\")\\n return 0\",\n \"def write_file(bytes, path: str):\\n\\n newFile = open(path + \\\".rex\\\", \\\"wb\\\")\\n newFile.write(bytes)\\n return True\",\n \"def write_file(self):\\n if self._write_file == None:\\n return\\n\\n try:\\n out = file(self._write_file, \\\"w\\\")\\n except IOError, e:\\n print e\\n sys.exit(1)\\n out.writelines(\\\"A cases\\\") \\n out.close()\",\n \"def write_to_file(output, data, datafields):\\n if (len(data) != len(datafields)):\\n print \\\"Error! number of data fields != number of headers!\\\"\\n print 'len: ', len(data), len(datafields)\\n print 'shape: ', np.shape(data), np.shape(datafields)\\n\\n ofile = open(output,'w')\\n ofile.write(\\\"# g(r) in the xy-plane from 2Drdf.py\\\\n\\\")\\n header = \\\"# chunk \\\"\\n for element in datafields:\\n header += element + \\\" \\\"\\n\\n header = header + '\\\\n'\\n ofile.write(header)\\n \\n it = 0\\n for i in xrange(len(data[0])):\\n line = str(it) + \\\" \\\"\\n it += 1\\n for j in xrange(len(data)):\\n line += str(float(data[j][i])) + \\\" \\\"\\n line += \\\"\\\\n\\\"\\n ofile.write(line)\\n \\n ofile.close()\\n print \\\"Finished writing file: \\\", output\",\n \"def cam_write(filename, M, N):\\n f = open(filename,'wb')\\n # write the header\\n f.write(TAG_CHAR)\\n M.astype('float64').tofile(f)\\n N.astype('float64').tofile(f)\\n f.close()\",\n \"def saveScalarStructuredGridVTK_binary(scalar,scalar_name,x,y,z,filename,dims):\\n \\n numEl_size = x.size; numEl = np.prod(numEl_size);\\n # open the file and write the ASCII header:\\n file = open(filename,'w')\\n file.write('# vtk DataFile Version 3.0\\\\n')\\n file.write('VTK file for data post-processed with Python\\\\n')\\n file.write('Binary\\\\n\\\\n')\\n file.write('DATASET STRUCTURED_GRID\\\\n')\\n file.write('DIMENSIONS %d %d %d \\\\n'%(dims[0],dims[1],dims[2]))\\n file.write('POINTS %d float\\\\n'%(numEl))\\n file.close()\\n \\n # append binary x,y,z data\\n file = open(filename,'ab')\\n for i in range(len(x)): # there really needs to be a better way.\\n pt = [x[i],y[i],z[i]]\\n pt_buf = array('f',pt)\\n pt_buf.byteswap()\\n file.write(pt_buf)\\n \\n \\n file.close()\\n \\n # append another ASCII sub header for the scalar data\\n file = open(filename,'a')\\n file.write('POINT_DATA %d \\\\n'%numEl)\\n file.write('SCALARS %s int\\\\n'%scalar_name)\\n file.write('LOOKUP_TABLE default\\\\n')\\n file.close()\\n \\n # append binary scalar data\\n file = open(filename,'ab')\\n p_buf = array('f',scalar); p_buf.byteswap()\\n file.write(p_buf)\\n file.close()\",\n \"def add_binary(self):\\n # Construct a binary representation for each genotype\\n binary = utils.genotypes_to_binary(self.wildtype,\\n self.genotypes,\\n self.mutations\\n )\\n\\n # Add this as a column to the map.\\n self.data['binary'] = binary\",\n \"def save_elem_file(self, output):\\n with open(output, 'wb') as fid:\\n self._write_elem_header(fid)\\n self._write_nodes(fid)\\n self._write_elements(fid)\\n self._write_neighbors(fid)\",\n \"def write(self, filename):\\n pass\",\n \"def write(self, filename):\\n pass\",\n \"def write_offsets(self):\\n\\n for offset in self.offsets:\\n self.db_file.write(struct.pack(\\\"<I\\\", offset))\",\n \"def write_object_file_to_file(self, file_name):\\n with open(file_name, 'wb+') as file:\\n file.write(self.object_file.to_binary_array())\",\n \"def write_binary(self,value):\\n self.write_uint32(len(value))\\n self.data.extend(value)\",\n \"def write(data):\",\n \"def write_opcodes(path, opcodes):\\n with open(path, \\\"w\\\") as file_handler:\\n for opcode in opcodes:\\n file_handler.write(opcode + \\\"\\\\n\\\")\",\n \"def write_bytes_to_file(bytes, filename):\\n try:\\n with open(filename, mode=\\\"bx\\\") as file:\\n file.write(bytes)\\n except FileExistsError:\\n os.remove(filename)\\n ResourceHandler.write_bytes_to_file(bytes, filename)\\n except Exception as e:\\n print(e)\",\n \"def write(filename):\\n print(uc.write(filename))\",\n \"def update_binary(self, offset, data):\\n log.debug(\\\"write binary {0} to {1}\\\".format(offset, offset+len(data)))\\n cmd = bytearray([0x00, 0xD6, offset/256, offset%256, len(data)])\\n cmd = cmd + bytearray(data)\\n rsp = self.transceive(cmd)\\n if rsp[-2:] != \\\"\\\\x90\\\\x00\\\":\\n raise Type4TagError(rsp[-2:])\",\n \"def write(self, filename, data, hdr):\\n pass\",\n \"def outputBigMatrix(cellNames, results, outFname, isGene=False):\\n logging.info(\\\"Writing data to file %s\\\" % outFname)\\n ofh = open(outFname, \\\"w\\\")\\n # write header\\n if isGene:\\n ofh.write(\\\"#gene\\\\t%s\\\\n\\\" % \\\"\\\\t\\\".join(cellNames))\\n else:\\n ofh.write(\\\"#transcript\\\\t%s\\\\n\\\" % \\\"\\\\t\\\".join(cellNames))\\n \\n # create a sorted list of all transcript names\\n logging.info(\\\"Getting transcript IDs\\\")\\n allTrans = set()\\n for res in results:\\n allTrans.update(res)\\n allTrans = list(allTrans)\\n allTrans.sort()\\n\\n # write out matrix\\n logging.info(\\\"Iterating over transcript IDs and writing to tab file\\\")\\n for trans in allTrans:\\n ofh.write(\\\"%s\\\\t\\\" % trans)\\n row = []\\n for countDict in results:\\n row.append(str(countDict.get(trans, 0)))\\n ofh.write(\\\"\\\\t\\\".join(row))\\n ofh.write(\\\"\\\\n\\\")\\n ofh.close()\\n\\n # also output as a binary file for now\\n # it's a lot easier and faster to parse, at least for python scripts\\n # can be read from python with a single line:\\n # matrix = marshal.load(open(\\\"data.tab.marshal\\\"))\\n # matrix is then a nested hash: cellName -> transcript -> count\\n binPath = outFname+\\\".marshal\\\"\\n logging.info(\\\"Writing %s\\\" % binPath)\\n allData = {}\\n for name, transDict in zip(cellNames, results):\\n allData[name] = transDict\\n marshal.dump(allData, open(binPath, \\\"wb\\\"))\",\n \"def write_files(self, basedir):\\n outdir = basedir / self.type\\n outdir.mkdir(parents=True, exist_ok=True)\\n\\n for point, row in zip(self.points, self.array):\\n filepath = outdir / point\\n with filepath.open('w') as f:\\n idx = 0\\n for ikey in self.pardict.keys():\\n f.write(\\\"{} {}\\\\n\\\".format(ikey, row[idx]))\\n idx += 1\\n logging.debug('wrote %s', filepath)\",\n \"def _write(self, out_file):\\n out_file.write(' '.encode()) # pad byte\\n out_file.write('{:4d}'.format(self.key).encode())\\n out_file.write(self.code.encode())\\n out_file.write((' '*18).encode()) # pad bytes\\n out_file.write('{:12d}'.format(self.numelem).encode())\\n out_file.write((' '*37).encode()) # pad bytes\\n out_file.write('{:1d}'.format(self.format).encode())\\n out_file.write('\\\\n'.encode())\\n\\n for elem in self.elems:\\n if self.format < 2:\\n out_file.write(' -1'.encode())\\n if self.format == 0:\\n out_file.write('{:5d}'.format(elem.number).encode())\\n else:\\n out_file.write('{:10d}'.format(elem.number).encode())\\n out_file.write('{:5d}'.format(elem.type).encode())\\n out_file.write('{:5d}'.format(elem.group).encode())\\n out_file.write('{:5d}'.format(elem.material).encode())\\n out_file.write('\\\\n'.encode())\\n num_nodes = FRDElem.nodesPerType[elem.type]\\n num_lines = int(num_nodes/(5*(3-self.format)+1))+1\\n for j in range(num_lines):\\n out_file.write(' -2'.encode()) # pad byte and key = -2\\n k_start = j*5*(3-self.format)\\n k_end = min(num_nodes, (j+1)*5*(3-self.format))\\n if self.format == 0:\\n for k in range(k_start, k_end):\\n out_file.write(\\n '{:5d}'.format(elem.nodes[k]).encode())\\n else:\\n for k in range(k_start, k_end):\\n out_file.write(\\n '{:10d}'.format(elem.nodes[k]).encode())\\n out_file.write('\\\\n'.encode()) # eol\\n else:\\n out_file.write(struct.pack('i', elem.number))\\n out_file.write(struct.pack('i', elem.type))\\n out_file.write(struct.pack('i', elem.group))\\n out_file.write(struct.pack('i', elem.material))\\n out_file.write(struct.pack('i'*num_nodes, *elem.nodes))\\n\\n if self.format < 2:\\n out_file.write(' -3\\\\n') # last record for ascii only\",\n \"def write_data():\",\n \"def write_neighnet(pathfolder, nif, neighnet, methodvalues):\\n ## Generate namefile\\n namefile = generate_namefile(pathfolder, methodvalues)\\n\\n ## Writting\\n db = shelve.open(namefile)\\n db['nif'] = nif\\n db['neighnet'] = neighnet\\n db['methodvalues'] = methodvalues\\n db.close()\",\n \"def saveDataToFile(fullFilename, binaryData):\\n with open(fullFilename, 'wb') as fp:\\n fp.write(binaryData)\\n fp.close()\\n # logging.debug(\\\"Complete save file %s\\\", fullFilename)\",\n \"def to_file(c, path, seq_types=None):\\n with open(path, \\\"w\\\") as f:\\n f.write(circuit_to_verilog(c, seq_types))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65858525","0.6368011","0.6283617","0.622919","0.6155533","0.6013805","0.5996172","0.5971584","0.59386206","0.5921192","0.591766","0.5843438","0.58248633","0.5801343","0.578895","0.5729028","0.57093227","0.5703158","0.56399626","0.56187046","0.56164056","0.5616271","0.560932","0.5608996","0.55241644","0.55212003","0.55159926","0.5445883","0.5433054","0.54202205","0.5419383","0.5407494","0.53902245","0.5389709","0.53860366","0.5357288","0.5338583","0.5332247","0.5326281","0.5322382","0.5305776","0.53014076","0.52875787","0.52830625","0.5270854","0.52676094","0.52668554","0.52622044","0.52518827","0.52430755","0.5241402","0.5238449","0.5217255","0.5217167","0.5199638","0.51954484","0.5195062","0.51862156","0.5181714","0.5181495","0.517316","0.5172678","0.5159637","0.5146116","0.51437426","0.5140595","0.5137366","0.5134192","0.5132425","0.5126812","0.5124784","0.51127124","0.510908","0.5107574","0.5098323","0.50910527","0.5082879","0.5078915","0.5078505","0.5078045","0.5075419","0.50708383","0.5063951","0.5063951","0.50570893","0.5052074","0.50509256","0.504759","0.5040404","0.5035949","0.50329053","0.503082","0.5020571","0.5006089","0.5002362","0.49987802","0.49976423","0.4993983","0.49904805","0.49795783"],"string":"[\n \"0.65858525\",\n \"0.6368011\",\n \"0.6283617\",\n \"0.622919\",\n \"0.6155533\",\n \"0.6013805\",\n \"0.5996172\",\n \"0.5971584\",\n \"0.59386206\",\n \"0.5921192\",\n \"0.591766\",\n \"0.5843438\",\n \"0.58248633\",\n \"0.5801343\",\n \"0.578895\",\n \"0.5729028\",\n \"0.57093227\",\n \"0.5703158\",\n \"0.56399626\",\n \"0.56187046\",\n \"0.56164056\",\n \"0.5616271\",\n \"0.560932\",\n \"0.5608996\",\n \"0.55241644\",\n \"0.55212003\",\n \"0.55159926\",\n \"0.5445883\",\n \"0.5433054\",\n \"0.54202205\",\n \"0.5419383\",\n \"0.5407494\",\n \"0.53902245\",\n \"0.5389709\",\n \"0.53860366\",\n \"0.5357288\",\n \"0.5338583\",\n \"0.5332247\",\n \"0.5326281\",\n \"0.5322382\",\n \"0.5305776\",\n \"0.53014076\",\n \"0.52875787\",\n \"0.52830625\",\n \"0.5270854\",\n \"0.52676094\",\n \"0.52668554\",\n \"0.52622044\",\n \"0.52518827\",\n \"0.52430755\",\n \"0.5241402\",\n \"0.5238449\",\n \"0.5217255\",\n \"0.5217167\",\n \"0.5199638\",\n \"0.51954484\",\n \"0.5195062\",\n \"0.51862156\",\n \"0.5181714\",\n \"0.5181495\",\n \"0.517316\",\n \"0.5172678\",\n \"0.5159637\",\n \"0.5146116\",\n \"0.51437426\",\n \"0.5140595\",\n \"0.5137366\",\n \"0.5134192\",\n \"0.5132425\",\n \"0.5126812\",\n \"0.5124784\",\n \"0.51127124\",\n \"0.510908\",\n \"0.5107574\",\n \"0.5098323\",\n \"0.50910527\",\n \"0.5082879\",\n \"0.5078915\",\n \"0.5078505\",\n \"0.5078045\",\n \"0.5075419\",\n \"0.50708383\",\n \"0.5063951\",\n \"0.5063951\",\n \"0.50570893\",\n \"0.5052074\",\n \"0.50509256\",\n \"0.504759\",\n \"0.5040404\",\n \"0.5035949\",\n \"0.50329053\",\n \"0.503082\",\n \"0.5020571\",\n \"0.5006089\",\n \"0.5002362\",\n \"0.49987802\",\n \"0.49976423\",\n \"0.4993983\",\n \"0.49904805\",\n \"0.49795783\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8135084"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":16498,"cells":{"query":{"kind":"string","value":"Finalize the GDSII stream library."},"document":{"kind":"string","value":"def close(self):\n self._outfile.write(struct.pack(\">2H\", 4, 0x0400))\n if self._close:\n self._outfile.close()"},"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 finalize(self):\r\n self.stream.finalize()","def finalize():","def finalize():","def finalize():","def finalize(self):\n # 027 Not needed in the simple FilesAdaptor. \n pass","def finalize(self):\r\n self.outfile_param.close()\r\n self.outfile_sim.close()","def finalize(self) -> None:\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\r\n pass","def finalize(self):","def finalize(self):","def write_finalize(self):\n check_call(LIB.HPPS_RecordIOWriteFinalize(self.handle))","def finalize():\n pass","def finalize():\n pass","def finalize(self): # real signature unknown; restored from __doc__\n pass","def finalize(self):\n if self.logging:\n self.train_writer.close()","def finalize():\n\n # Close syslog like a good citizen\n syslog.closelog()","def finalize(self):\n \n if self.outpath:\n # User specified an file path to which to write\n # the Group Scheduling Events, Attempt to open\n # specified file for writing.\n #\n try:\n outstream = open(self.outpath, 'w')\n except IOError, eargs:\n # Nope, it isn't writable due to an IOError. \n # Let them know the error and warn them that\n # the default action is to fallback to stdout\n # as an output stream if the output they \n # specify fails to initialize.\n #\n print 'Error: CCSMFilter.finalize : %s' % eargs\n print 'Warning: Falling back to output stream sys.stdout'\n outstream = sys.stdout\n else:\n outstream = sys.stdout\n \n # Print all the events to the output stream.\n # \n for ccsm_event in self.ccsm_events:\n print >> outstream, ccsm_event\n \n # Check to see if the pointer to \n # stdout is the same as the pointer\n # to our outstream.\n #\n if outstream != sys.stdout:\n # It isn't so close the file. \n # If our outstream was stdout you probably wouldn't\n # want to close it.\n #\n outstream.close()","def finalize(self):\n return","def cleanup(self):\n self.io.close()","def _cleanup(self):\n \tself._gqcnn.close_session()","def finalize(self):\n print('Cleaning up...')","def _Close(self):\n self._compression_method = None","def finalize(self):\n if self._writer:\n self.flush()\n if self._archive_file:\n self._archive_file.close()","def finalize(self):\n raise NotImplementedError('Must be implemented in subclasses.')","def close(self):\n self._stream.close()\n self._arch.close()","def finalize(self):\r\n\r\n self._flush()\r\n self.context.close()","def Finalize():\n pass","def finalise(self):","def close(self):\n self._raw_stream.close()","def finalize(self, **kwargs: Any) -> None:\n pass","def close(self):\n _check_init()\n if self._output is not None:\n self._output.Close()\n self._output = None","def finish(self):\n self._fout.add_size()\n self._fout.add_padding()\n self._fout.close()","def close(self):\n self.p.close(self.inStream)","def finalize(self, interrupted=False):\n pass","def finalize() -> None:\n collective.finalize()","def finalize(self): # pylint: disable=no-self-use\n return","def _finalize(self):\n if self._initialized:\n if self.connected():\n if self.swo_enabled():\n self.swo_stop()\n\n if self.opened():\n self.close()","def finalize():\n global interpreter\n del interpreter\n blotish._cleanup()\n\n # Set the progress printing state to whatever it was before\n import paraview.servermanager\n global wasProgressPrinting\n paraview.servermanager.SetProgressPrintingEnabled(wasProgressPrinting)","def destroy_input_stream(self):\n\n # Destroy the stream\n del self.inp\n\n # Garbage collect\n gc.collect()","def tearDown(self):\n self.codec.stream.flush()\n self.codec.stream.close()","def release(self):\n self.stream.release()","def Finalize(self):\n return _gmat_py.ICRFFile_Finalize(self)","def close(self):\n self.output.close()","def _finalise_construction(self):\n pass","def close(self):\n self._stream.close()\n self._stream = None","def finalize(self):\n if self._file:\n toLog(\"Closing file `{0}`\".format(self._fname), True)\n self._file.close()\n self._file = None","def finalize(self):\n self.logger.debug(\"Finalizing...\")\n self.listeners = []\n self.finalizing = True","def _on_finalize(self):\n pass","def finalize(self):\n pass\n #fftw2py.clean_fftw_solver(self.output_field.dimension)","def _close_stream(self):\n if self.stream:\n try:\n if not self.stream.closed:\n self.stream.flush()\n self.stream.close()\n finally:\n self.stream = None","def finalize(self):\n self.ratings.close()\n self.users.close()\n self.movies.close()","def close(self) -> None:\n lib.Fapi_Finalize(self._ctx_pp)","def close(self):\n if self.closed:\n return\n self._stream.close()\n self._stream = None","def finalize(self):\n self.stop()","def cleanup():\n # global the_vx_ifc\n print(\"\\n cleaning up...\", end=' ')\n the_vx_ifc.close()\n print('connections closed\\n')","def end(self):\n self.flush()\n\n # Free some memory and disk space\n self._plugins_dict = {}\n self._options_dict = {}\n self._scan_targets = None\n self._errors.cleanup()\n self._jinja2_env = None","def _close(self):\n self.write_data(self.write_queue)\n self.write_compound(self.write_compound_queue)","def end(self):\n self._bc.close()","def close():","def _epilogue(self):\n LOG.info(\"We could clean up the database connection.\")","def finalize():\n global interpreter\n interpreter = None\n global doProgressToggle\n if doProgressToggle: paraview.servermanager.ToggleProgressPrinting()","def end_serialization(self):\n pass","def finalize(self):\n if self.status != 'Camera is idle, waiting for instructions.':\n self.abort_acquisition()\n self.cooler_on = False\n self.free_int_mem()\n self.lib.ShutDown()","def close_datafile(fs):\r\n fs.close() # fs is the output from init_datafile\r","def close(self) -> None:\n self._stream.close()","def stream_closed(self,stream):\n pass","async def finalize():\n for hub in Hub.hubs:\n await hub.finalize()\n await hub.emit('finalized')\n\n for hub in Hub.hubs:\n await hub._disconnect()\n\n # Print out the port information in debug mode\n for hub in Hub.hubs:\n if hub.query_port_info:\n hub.message_info(pprint.pformat(hub.port_info))\n\n # At this point no device should be connected, but\n # just to make sure...\n await BLEventQ.instance.disconnect_all()","def finalize(self):\n if self.rank > 0:\n return\n\n self._check_all_files_are_saved()\n self._collect_embedding_id_offset()\n\n self._build_ivf()\n self._update_metadata()","def close(istream):\n # e.g. close files or disconnect apis\n istream.close()","def finalize(self, ):\n dat = self.outd\n for nm in set(data_defs.keys()) - self.vars_read:\n _pop(dat, nm)\n for nm in self.cfg:\n dat['attrs'][nm] = self.cfg[nm]\n dat['attrs']['fs'] = (dat['attrs']['sec_between_ping_groups'] *\n dat['attrs']['pings_per_ensemble']) ** (-1)\n for nm in data_defs:\n shp = data_defs[nm][0]\n if len(shp) and shp[0] == 'nc' and _in_group(dat, nm):\n _setd(dat, nm, np.swapaxes(_get(dat, nm), 0, 1))","def close(self):\n self.fout.close()","def __del__(self):\n\t\tself.s.close()","def __del__(self):\n\n if self._cs is not None:\n self._cs.close()","def _on_close(self):\n self._stream = None\n self._is_secure = False\n self._process_request()","def free(self):\r\n return bass_call(BASS_StreamFree, self.handle)","def final_cleanup(self):\n raise NotImplementedError()","def __del__(self):\n self.file_out.close()","def finalize(self):\n\t\tself.logger.info(\"Please wait while finalizing the operation.. Thank you\")\n\t\tself.save_checkpoint()\n\t\tself.summary_writer.export_scalars_to_json(\"{}all_scalars.json\".format(self.config.summary_dir))\n\t\tself.summary_writer.close()\n\t\tself.data_loader.finalize()\n\t\tif self.config.output_model == True:\n\t\t\ttry:\n\t\t\t\tself.logger.info('Saving model for external usage.')\n\t\t\t\tself.load_checkpoint('model_best.pth.tar')\n\t\t\t\ttraced = torch.jit.trace(self.model,self.data_loader.train_loader.dataset[:2][0].float().to(self.device))\n\t\t\t\ttraced.save(self.config.output_model_path)\n\t\t\texcept IOError:\n\t\t\t\tself.logger.info('Output model path not found.')","def finalize(self):\n return b\"\"","def finalize(self):\n if not hasattr(self, 'finish'):\n self.logger.warning('Class does not have a finalize statement')","def on_connection_close(self):\n self._stat.http_stream_close += 1\n self._logger.info(\"HTTP EventStream %s closed\", self)\n self.finish()\n asyncio.async(self._nc_handler.close(), loop=self._asyncio_loop)","def finalize(self):\n sys.stderr.write(f\"{self._message} finished after {(time.time()-self._startTime):.1f}s \"\n \"at \"+time.strftime(\"%H:%M:%S\", time.localtime())+\" \\n\")","def finalize(self):\n sys.stderr.write(f\"{self._message} finished after {(time.time()-self._startTime):.1f}s \"\n \"at \"+time.strftime(\"%H:%M:%S\", time.localtime())+\" \\n\")","def close(self):\n self.out_file.close()","def dispose(self) -> None:","def finalize(self, *args, **kwargs):\n self._add_all_odes_to_interface()\n self._transform_derivatives_on_rhs()\n super(InterfaceGenerator, self).finalize(*args, **kwargs)","def finish(self):\n data_size = self.get_size() - self.HEADER_SIZE\n self.write_header(data_size=data_size)\n crc = self.crc()\n self.buf.seek(0, 2)\n self.buf.write(crc)","def finalize_statistics_collection(self):\n # Close all files.\n self.testing_batch_stats_file.close()\n self.testing_set_stats_file.close()","def close(self):\n self._state = Computation.STATE_COMPLETED\n if self._stream:\n self._stream.close()\n self._stream = None","def _CloseOutputFiles(self):\n self.gfile.close()\n self.efile.close()","def finalize():\n\n print(\"\"\"\n The script analysis/sedov_compare.py can be used to analyze these\n results. That will perform an average at constant radius and\n compare the radial profiles to the exact solution. Sample exact\n data is provided as analysis/cylindrical-sedov.out\n \"\"\")","def finalize(self):\n logger.debug(\"Generation Complete\")\n self.events.generation_complete()","def terminated(self):\n gc3libs.log.debug(\" ...done.\")","def release(self):\r\n for s in self.streams:\r\n s.release()","def close(self):\n self.outfd.close()"],"string":"[\n \"def finalize(self):\\r\\n self.stream.finalize()\",\n \"def finalize():\",\n \"def finalize():\",\n \"def finalize():\",\n \"def finalize(self):\\n # 027 Not needed in the simple FilesAdaptor. \\n pass\",\n \"def finalize(self):\\r\\n self.outfile_param.close()\\r\\n self.outfile_sim.close()\",\n \"def finalize(self) -> None:\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\r\\n pass\",\n \"def finalize(self):\",\n \"def finalize(self):\",\n \"def write_finalize(self):\\n check_call(LIB.HPPS_RecordIOWriteFinalize(self.handle))\",\n \"def finalize():\\n pass\",\n \"def finalize():\\n pass\",\n \"def finalize(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def finalize(self):\\n if self.logging:\\n self.train_writer.close()\",\n \"def finalize():\\n\\n # Close syslog like a good citizen\\n syslog.closelog()\",\n \"def finalize(self):\\n \\n if self.outpath:\\n # User specified an file path to which to write\\n # the Group Scheduling Events, Attempt to open\\n # specified file for writing.\\n #\\n try:\\n outstream = open(self.outpath, 'w')\\n except IOError, eargs:\\n # Nope, it isn't writable due to an IOError. \\n # Let them know the error and warn them that\\n # the default action is to fallback to stdout\\n # as an output stream if the output they \\n # specify fails to initialize.\\n #\\n print 'Error: CCSMFilter.finalize : %s' % eargs\\n print 'Warning: Falling back to output stream sys.stdout'\\n outstream = sys.stdout\\n else:\\n outstream = sys.stdout\\n \\n # Print all the events to the output stream.\\n # \\n for ccsm_event in self.ccsm_events:\\n print >> outstream, ccsm_event\\n \\n # Check to see if the pointer to \\n # stdout is the same as the pointer\\n # to our outstream.\\n #\\n if outstream != sys.stdout:\\n # It isn't so close the file. \\n # If our outstream was stdout you probably wouldn't\\n # want to close it.\\n #\\n outstream.close()\",\n \"def finalize(self):\\n return\",\n \"def cleanup(self):\\n self.io.close()\",\n \"def _cleanup(self):\\n \\tself._gqcnn.close_session()\",\n \"def finalize(self):\\n print('Cleaning up...')\",\n \"def _Close(self):\\n self._compression_method = None\",\n \"def finalize(self):\\n if self._writer:\\n self.flush()\\n if self._archive_file:\\n self._archive_file.close()\",\n \"def finalize(self):\\n raise NotImplementedError('Must be implemented in subclasses.')\",\n \"def close(self):\\n self._stream.close()\\n self._arch.close()\",\n \"def finalize(self):\\r\\n\\r\\n self._flush()\\r\\n self.context.close()\",\n \"def Finalize():\\n pass\",\n \"def finalise(self):\",\n \"def close(self):\\n self._raw_stream.close()\",\n \"def finalize(self, **kwargs: Any) -> None:\\n pass\",\n \"def close(self):\\n _check_init()\\n if self._output is not None:\\n self._output.Close()\\n self._output = None\",\n \"def finish(self):\\n self._fout.add_size()\\n self._fout.add_padding()\\n self._fout.close()\",\n \"def close(self):\\n self.p.close(self.inStream)\",\n \"def finalize(self, interrupted=False):\\n pass\",\n \"def finalize() -> None:\\n collective.finalize()\",\n \"def finalize(self): # pylint: disable=no-self-use\\n return\",\n \"def _finalize(self):\\n if self._initialized:\\n if self.connected():\\n if self.swo_enabled():\\n self.swo_stop()\\n\\n if self.opened():\\n self.close()\",\n \"def finalize():\\n global interpreter\\n del interpreter\\n blotish._cleanup()\\n\\n # Set the progress printing state to whatever it was before\\n import paraview.servermanager\\n global wasProgressPrinting\\n paraview.servermanager.SetProgressPrintingEnabled(wasProgressPrinting)\",\n \"def destroy_input_stream(self):\\n\\n # Destroy the stream\\n del self.inp\\n\\n # Garbage collect\\n gc.collect()\",\n \"def tearDown(self):\\n self.codec.stream.flush()\\n self.codec.stream.close()\",\n \"def release(self):\\n self.stream.release()\",\n \"def Finalize(self):\\n return _gmat_py.ICRFFile_Finalize(self)\",\n \"def close(self):\\n self.output.close()\",\n \"def _finalise_construction(self):\\n pass\",\n \"def close(self):\\n self._stream.close()\\n self._stream = None\",\n \"def finalize(self):\\n if self._file:\\n toLog(\\\"Closing file `{0}`\\\".format(self._fname), True)\\n self._file.close()\\n self._file = None\",\n \"def finalize(self):\\n self.logger.debug(\\\"Finalizing...\\\")\\n self.listeners = []\\n self.finalizing = True\",\n \"def _on_finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\\n #fftw2py.clean_fftw_solver(self.output_field.dimension)\",\n \"def _close_stream(self):\\n if self.stream:\\n try:\\n if not self.stream.closed:\\n self.stream.flush()\\n self.stream.close()\\n finally:\\n self.stream = None\",\n \"def finalize(self):\\n self.ratings.close()\\n self.users.close()\\n self.movies.close()\",\n \"def close(self) -> None:\\n lib.Fapi_Finalize(self._ctx_pp)\",\n \"def close(self):\\n if self.closed:\\n return\\n self._stream.close()\\n self._stream = None\",\n \"def finalize(self):\\n self.stop()\",\n \"def cleanup():\\n # global the_vx_ifc\\n print(\\\"\\\\n cleaning up...\\\", end=' ')\\n the_vx_ifc.close()\\n print('connections closed\\\\n')\",\n \"def end(self):\\n self.flush()\\n\\n # Free some memory and disk space\\n self._plugins_dict = {}\\n self._options_dict = {}\\n self._scan_targets = None\\n self._errors.cleanup()\\n self._jinja2_env = None\",\n \"def _close(self):\\n self.write_data(self.write_queue)\\n self.write_compound(self.write_compound_queue)\",\n \"def end(self):\\n self._bc.close()\",\n \"def close():\",\n \"def _epilogue(self):\\n LOG.info(\\\"We could clean up the database connection.\\\")\",\n \"def finalize():\\n global interpreter\\n interpreter = None\\n global doProgressToggle\\n if doProgressToggle: paraview.servermanager.ToggleProgressPrinting()\",\n \"def end_serialization(self):\\n pass\",\n \"def finalize(self):\\n if self.status != 'Camera is idle, waiting for instructions.':\\n self.abort_acquisition()\\n self.cooler_on = False\\n self.free_int_mem()\\n self.lib.ShutDown()\",\n \"def close_datafile(fs):\\r\\n fs.close() # fs is the output from init_datafile\\r\",\n \"def close(self) -> None:\\n self._stream.close()\",\n \"def stream_closed(self,stream):\\n pass\",\n \"async def finalize():\\n for hub in Hub.hubs:\\n await hub.finalize()\\n await hub.emit('finalized')\\n\\n for hub in Hub.hubs:\\n await hub._disconnect()\\n\\n # Print out the port information in debug mode\\n for hub in Hub.hubs:\\n if hub.query_port_info:\\n hub.message_info(pprint.pformat(hub.port_info))\\n\\n # At this point no device should be connected, but\\n # just to make sure...\\n await BLEventQ.instance.disconnect_all()\",\n \"def finalize(self):\\n if self.rank > 0:\\n return\\n\\n self._check_all_files_are_saved()\\n self._collect_embedding_id_offset()\\n\\n self._build_ivf()\\n self._update_metadata()\",\n \"def close(istream):\\n # e.g. close files or disconnect apis\\n istream.close()\",\n \"def finalize(self, ):\\n dat = self.outd\\n for nm in set(data_defs.keys()) - self.vars_read:\\n _pop(dat, nm)\\n for nm in self.cfg:\\n dat['attrs'][nm] = self.cfg[nm]\\n dat['attrs']['fs'] = (dat['attrs']['sec_between_ping_groups'] *\\n dat['attrs']['pings_per_ensemble']) ** (-1)\\n for nm in data_defs:\\n shp = data_defs[nm][0]\\n if len(shp) and shp[0] == 'nc' and _in_group(dat, nm):\\n _setd(dat, nm, np.swapaxes(_get(dat, nm), 0, 1))\",\n \"def close(self):\\n self.fout.close()\",\n \"def __del__(self):\\n\\t\\tself.s.close()\",\n \"def __del__(self):\\n\\n if self._cs is not None:\\n self._cs.close()\",\n \"def _on_close(self):\\n self._stream = None\\n self._is_secure = False\\n self._process_request()\",\n \"def free(self):\\r\\n return bass_call(BASS_StreamFree, self.handle)\",\n \"def final_cleanup(self):\\n raise NotImplementedError()\",\n \"def __del__(self):\\n self.file_out.close()\",\n \"def finalize(self):\\n\\t\\tself.logger.info(\\\"Please wait while finalizing the operation.. Thank you\\\")\\n\\t\\tself.save_checkpoint()\\n\\t\\tself.summary_writer.export_scalars_to_json(\\\"{}all_scalars.json\\\".format(self.config.summary_dir))\\n\\t\\tself.summary_writer.close()\\n\\t\\tself.data_loader.finalize()\\n\\t\\tif self.config.output_model == True:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tself.logger.info('Saving model for external usage.')\\n\\t\\t\\t\\tself.load_checkpoint('model_best.pth.tar')\\n\\t\\t\\t\\ttraced = torch.jit.trace(self.model,self.data_loader.train_loader.dataset[:2][0].float().to(self.device))\\n\\t\\t\\t\\ttraced.save(self.config.output_model_path)\\n\\t\\t\\texcept IOError:\\n\\t\\t\\t\\tself.logger.info('Output model path not found.')\",\n \"def finalize(self):\\n return b\\\"\\\"\",\n \"def finalize(self):\\n if not hasattr(self, 'finish'):\\n self.logger.warning('Class does not have a finalize statement')\",\n \"def on_connection_close(self):\\n self._stat.http_stream_close += 1\\n self._logger.info(\\\"HTTP EventStream %s closed\\\", self)\\n self.finish()\\n asyncio.async(self._nc_handler.close(), loop=self._asyncio_loop)\",\n \"def finalize(self):\\n sys.stderr.write(f\\\"{self._message} finished after {(time.time()-self._startTime):.1f}s \\\"\\n \\\"at \\\"+time.strftime(\\\"%H:%M:%S\\\", time.localtime())+\\\" \\\\n\\\")\",\n \"def finalize(self):\\n sys.stderr.write(f\\\"{self._message} finished after {(time.time()-self._startTime):.1f}s \\\"\\n \\\"at \\\"+time.strftime(\\\"%H:%M:%S\\\", time.localtime())+\\\" \\\\n\\\")\",\n \"def close(self):\\n self.out_file.close()\",\n \"def dispose(self) -> None:\",\n \"def finalize(self, *args, **kwargs):\\n self._add_all_odes_to_interface()\\n self._transform_derivatives_on_rhs()\\n super(InterfaceGenerator, self).finalize(*args, **kwargs)\",\n \"def finish(self):\\n data_size = self.get_size() - self.HEADER_SIZE\\n self.write_header(data_size=data_size)\\n crc = self.crc()\\n self.buf.seek(0, 2)\\n self.buf.write(crc)\",\n \"def finalize_statistics_collection(self):\\n # Close all files.\\n self.testing_batch_stats_file.close()\\n self.testing_set_stats_file.close()\",\n \"def close(self):\\n self._state = Computation.STATE_COMPLETED\\n if self._stream:\\n self._stream.close()\\n self._stream = None\",\n \"def _CloseOutputFiles(self):\\n self.gfile.close()\\n self.efile.close()\",\n \"def finalize():\\n\\n print(\\\"\\\"\\\"\\n The script analysis/sedov_compare.py can be used to analyze these\\n results. That will perform an average at constant radius and\\n compare the radial profiles to the exact solution. Sample exact\\n data is provided as analysis/cylindrical-sedov.out\\n \\\"\\\"\\\")\",\n \"def finalize(self):\\n logger.debug(\\\"Generation Complete\\\")\\n self.events.generation_complete()\",\n \"def terminated(self):\\n gc3libs.log.debug(\\\" ...done.\\\")\",\n \"def release(self):\\r\\n for s in self.streams:\\r\\n s.release()\",\n \"def close(self):\\n self.outfd.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7394158","0.6610522","0.6610522","0.6610522","0.660409","0.6511681","0.641157","0.63843083","0.63843083","0.63843083","0.63843083","0.63843083","0.63843083","0.6372242","0.6350792","0.6350792","0.63461405","0.63144404","0.63144404","0.6277247","0.62279004","0.61871773","0.6130391","0.61290675","0.60964596","0.6088324","0.6078075","0.59683716","0.594034","0.59077585","0.58995587","0.5888804","0.5867989","0.5862838","0.5859735","0.582381","0.5810273","0.57717806","0.5769286","0.57626885","0.57460916","0.57280546","0.569544","0.56922024","0.5656319","0.56444836","0.56326216","0.5624955","0.5601333","0.55930066","0.5572756","0.5572163","0.5567545","0.5563192","0.55627453","0.55625415","0.55551577","0.55465347","0.5540465","0.5538025","0.5530413","0.55302763","0.5511336","0.54989505","0.5486064","0.54838437","0.5475903","0.54711175","0.5467588","0.54612756","0.5458392","0.5457335","0.5446424","0.54433155","0.5441536","0.5433734","0.5424348","0.54223156","0.54204017","0.54070264","0.53866696","0.53860486","0.53848374","0.5383833","0.5370048","0.53695196","0.53610975","0.5347914","0.5347914","0.5343625","0.53373206","0.5336721","0.533487","0.53333104","0.53255314","0.532427","0.53240484","0.53154296","0.53111994","0.5307123","0.5295797"],"string":"[\n \"0.7394158\",\n \"0.6610522\",\n \"0.6610522\",\n \"0.6610522\",\n \"0.660409\",\n \"0.6511681\",\n \"0.641157\",\n \"0.63843083\",\n \"0.63843083\",\n \"0.63843083\",\n \"0.63843083\",\n \"0.63843083\",\n \"0.63843083\",\n \"0.6372242\",\n \"0.6350792\",\n \"0.6350792\",\n \"0.63461405\",\n \"0.63144404\",\n \"0.63144404\",\n \"0.6277247\",\n \"0.62279004\",\n \"0.61871773\",\n \"0.6130391\",\n \"0.61290675\",\n \"0.60964596\",\n \"0.6088324\",\n \"0.6078075\",\n \"0.59683716\",\n \"0.594034\",\n \"0.59077585\",\n \"0.58995587\",\n \"0.5888804\",\n \"0.5867989\",\n \"0.5862838\",\n \"0.5859735\",\n \"0.582381\",\n \"0.5810273\",\n \"0.57717806\",\n \"0.5769286\",\n \"0.57626885\",\n \"0.57460916\",\n \"0.57280546\",\n \"0.569544\",\n \"0.56922024\",\n \"0.5656319\",\n \"0.56444836\",\n \"0.56326216\",\n \"0.5624955\",\n \"0.5601333\",\n \"0.55930066\",\n \"0.5572756\",\n \"0.5572163\",\n \"0.5567545\",\n \"0.5563192\",\n \"0.55627453\",\n \"0.55625415\",\n \"0.55551577\",\n \"0.55465347\",\n \"0.5540465\",\n \"0.5538025\",\n \"0.5530413\",\n \"0.55302763\",\n \"0.5511336\",\n \"0.54989505\",\n \"0.5486064\",\n \"0.54838437\",\n \"0.5475903\",\n \"0.54711175\",\n \"0.5467588\",\n \"0.54612756\",\n \"0.5458392\",\n \"0.5457335\",\n \"0.5446424\",\n \"0.54433155\",\n \"0.5441536\",\n \"0.5433734\",\n \"0.5424348\",\n \"0.54223156\",\n \"0.54204017\",\n \"0.54070264\",\n \"0.53866696\",\n \"0.53860486\",\n \"0.53848374\",\n \"0.5383833\",\n \"0.5370048\",\n \"0.53695196\",\n \"0.53610975\",\n \"0.5347914\",\n \"0.5347914\",\n \"0.5343625\",\n \"0.53373206\",\n \"0.5336721\",\n \"0.533487\",\n \"0.53333104\",\n \"0.53255314\",\n \"0.532427\",\n \"0.53240484\",\n \"0.53154296\",\n \"0.53111994\",\n \"0.5307123\",\n \"0.5295797\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":16499,"cells":{"query":{"kind":"string","value":"Return the unit and precision used in the GDS stream file."},"document":{"kind":"string","value":"def get_gds_units(infile):\n close = True\n if hasattr(infile, \"__fspath__\"):\n infile = open(infile.__fspath__(), \"rb\")\n elif isinstance(infile, (basestring, Path)):\n infile = open(infile, \"rb\")\n else:\n close = False\n unit = precision = None\n for rec_type, data in _raw_record_reader(infile):\n # UNITS\n if rec_type == 0x03:\n db_user = _eight_byte_real_to_float(data[4:12])\n db_meters = _eight_byte_real_to_float(data[12:])\n unit = db_meters / db_user\n precision = db_meters\n break\n if close:\n infile.close()\n return (unit, precision)"},"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_precision(self):\n ...","def unit_of_measurement(self) -> str:\n return FPS","def unit_of_measurement(self) -> str:\n return FPS","def unit_of_measurement(self):\n return self._metadata[1]","def GetDataPrecision():\n return _gmat_py.GmatBase_GetDataPrecision()","def GmatBase_GetDataPrecision():\n return _gmat_py.GmatBase_GetDataPrecision()","def _prec(self):\n prec = int(self.get_par(\"precision\"))\n if prec == 0:\n return \"f\"\n else:\n return \".{0}f\".format(prec)","def getSize(self, precision=1):\n kilo = 1000.0\n if self.size < kilo:\n return str(self.size) + \"B\"\n elif self.size < kilo ** 2:\n return str(round(self.size / kilo, precision)) + \"K\"\n elif self.size < kilo ** 3:\n return str(round(self.size / (kilo ** 2), precision)) + \"M\"\n elif self.size < kilo ** 4:\n return str(round(self.size / (kilo ** 3), precision)) + \"G\"\n else:\n return str(round(self.size / (kilo ** 4), precision)) + \"T\"","def unit_of_measurement(self) -> str:\n return MS","def unit_of_measurement(self):\r\n return self._sensor_cfg[1]","def unit_of_measurement(self):\r\n return self._sensor_cfg[1]","def get_observed_precision(self):\n return self.get_precision()","def unit_of_measurement(self) -> str:\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self.device.unit()","def unit_of_measurement(self):\n return self._config.get(CONF_UNIT_OF_MEASUREMENT)","def unit_of_measurement(self) -> str:\n return self._unit","def GetTimePrecision():\n return _gmat_py.GmatBase_GetTimePrecision()","def unit_of_measurement(self):\n return self.sensor_type[\"unit\"]","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._unit","def unit_of_measurement(self):\n return self._unit","def unit_of_measurement(self):\n return self._unit","def unit_of_measurement(self):\n return self._unit","def unit_of_measurement(self):\n return self._unit","def unit_of_measurement(self):\n return self._unit","def unit_of_measurement(self):\n return self._unit","def unit_of_measurement(self):\n return self.var_units","def unit_of_measurement(self):\n return self._var_unit","def unit_of_measurement(self):\n return self._var_unit","def units(self, size=\"G\", transfer='GB/s'): # YAML","def us(self):\n return 1000 * 1000 * self.read()","def get_precision(self):\n config_str = self.raw_sensor_strings[1].split()[4] # Byte 5 is the config register\n bit_base = int(config_str, 16) >> 5 # Bit 5-6 contains the resolution, cut off the rest\n return bit_base + 9 # min. is 9 bits","def unit_of_measurement(self):\n return self._sensor.unit","def precision(self) :\n return self.__precision","def precision(self) :\n return self.__precision","def GmatBase_GetTimePrecision():\n return _gmat_py.GmatBase_GetTimePrecision()","def test_get_std(self):\n\n std = self.info_list.get_std()\n self.assertEqual(std, 111.08728376994648)","def native_unit_of_measurement(self):\n return self._unit_of_measurement","def unit_of_measurement(self):\n return self._sensor_type.unit","def unit_of_measurement(self):\n return SENSOR_TYPES[self.sensor][1]","def unit_of_measurement(self):\n return SENSOR_TYPES[self.variable][1]","def unit_of_measurement(self):\n return SENSOR_TYPES[self.variable][1]","def get_std(self):\n return self.serie.std()","def _get_precision(self) -> float:\n precicions = [PRECISION_WHOLE, PRECISION_HALVES, PRECISION_TENTHS]\n static_info = self._static_info\n if static_info.visual_current_temperature_step != 0:\n step = static_info.visual_current_temperature_step\n else:\n step = static_info.visual_target_temperature_step\n for prec in precicions:\n if step >= prec:\n return prec\n # Fall back to highest precision, tenths\n return PRECISION_TENTHS","def unit_of_measurement(self) -> Any:\n return PERCENTAGE","def unit_of_measurement(self):\n if self._xfinity_data.unit is not None:\n return self._xfinity_data.unit","def precision(self, s=''):\n ptformatter = self.shell.display_formatter.formatters['text/plain']\n ptformatter.float_precision = s\n return ptformatter.float_format","def unit_of_measurement(self):\n return self._units","def unit_of_measurement(self):\n return self.display_currency","def unit_of_measurement(self):\n return SENSOR_TYPES[self._type][2]","def unit_of_measurement(self):\n return SENSOR_TYPES[self._type][2]","def unit_of_measurement(self):\n return None","def unit_of_measurement(self):\n return SENSOR_TYPES[self.type][1]","def precision(self):\n string = self.ask('od;E;') # get the actual output\n i1 = string.find('.')\n # find the indices of the dot before the decimal part and the E before\n # the exponent\n i2 = string.find('E', i1)\n # calculate the number of digit in the decimal part\n decimals = i2 - i1 - 1\n exponent = int(string[i2 + 1:])\n prec = 10**(-decimals + exponent) # calculate te precision\n return prec","def getUnits(self):\n return _libsbml.Parameter_getUnits(self)","def get_gsize(self):\n gsize_file = Genome(self.genome).get_fasize()\n gsize = 0\n with open(gsize_file, 'rt') as fi:\n for a in fi:\n c, n = a.strip().split('\\t')\n gsize += int(n)\n return gsize","def result(self):\n return (\"Precision@\" + str(self.length) + \": \"), (self.hit / self.test)","def unit_of_measurement(self):\n return UNIT_GALLONS_PER_MINUTE","def unit_of_measurement(self):\n return self.values.primary.units","def unit(self):\n return self._unit","def GetTransformPrecision(self):\n return _itkSpatialObjectWriterPython.itkSpatialObjectWriter2_GetTransformPrecision(self)","def get_units(self,):\n self.UNITS = {'pressure':'Pa',}\n return","def unit_of_measurement(self):\n return SENSOR_UNITS.get(self._sensor_name, None)","def unit_of_measurement(self):\n return SENSOR_UNITS.get(self._sensor_name, None)","def unit_of_measurement(self):\n return SENSOR_TYPES[self._type][1]","def get_units(self):\n return str(self._modeler.GetModelUnits())","def unit_of_measurement(self):\n return SENSOR_TYPES[self._sensor][0]","def unit_of_measurement(self):\n return LENGTH_METERS","def get_unit(self):\n return self.unit","def _get_units(self):\n #assert self.ser.isOpen()\n\n self.serial_connection.write('UNI' + self.CR + self.LF)\n acknowledgement = self.serial_connection.readline()\n self._check_acknowledgement(acknowledgement)\n\n self.serial_connection.write(self.ENQ)\n unit = self.MEASUREMENT_UNITS[self.serial_connection.readline().rstrip(self.LF).rstrip(self.CR)]\n\n self.serial_connection.write(self.CR + self.LF)\n\n return unit","def prec(self):\n return self._prec","def prec(self):\n return self._prec","def getTimeUnits(self):\n return _libsbml.KineticLaw_getTimeUnits(self)","def unit_of_measurement(self):\n return self._tasmota_entity.unit","def unit_of_measurement(self):\n return '%'","def get_grating_lines_per_mm(self):\r\n msg = struct.pack('>2B', 56, 2)\r\n response = self.query(msg)\r\n return struct.unpack('>H', response[:2])[0]","def totalUnits(self):\n\t\treturn self.units","def unit_of_measurement(self):\n return SENSOR_TYPES.get(self._sensor_type)[1]","def unit_of_measurement(self):\n return SENSOR_TYPES.get(self._sensor_type)[1]","def unit_of_measure(self):\n try:\n uom = self.metadata['geosoft']['dataset']['geo:unitofmeasurement']['#text']\n except KeyError:\n uom = ''\n return uom","def unit_of_measurement(self):\n\n if self._sensor_class == DEVICE_CLASS_TEMPERATURE:\n return TEMP_CELSIUS\n\n elif self._sensor_class == DEVICE_CLASS_HUMIDITY:\n return '%'","def unit_of_measurement(self):\n return self.temperature_unit","def get_numerical_repr(self):\r\n return \"%s\\t%s\\t%.2f\\n\" % (self.trf_period,\r\n self.trf_array_length,\r\n self.trf_array_gc)","def precision(self):\n return PRECISION_WHOLE","def get_precision(TP, FP):\n precision = TP / (TP + FP)\n return precision","def GetTransformPrecision(self):\n return _itkSpatialObjectWriterPython.itkSpatialObjectWriter3_GetTransformPrecision(self)","def getProfileSize(self):\n return convToUnits(self.profileBytes, divby=1000)"],"string":"[\n \"def get_precision(self):\\n ...\",\n \"def unit_of_measurement(self) -> str:\\n return FPS\",\n \"def unit_of_measurement(self) -> str:\\n return FPS\",\n \"def unit_of_measurement(self):\\n return self._metadata[1]\",\n \"def GetDataPrecision():\\n return _gmat_py.GmatBase_GetDataPrecision()\",\n \"def GmatBase_GetDataPrecision():\\n return _gmat_py.GmatBase_GetDataPrecision()\",\n \"def _prec(self):\\n prec = int(self.get_par(\\\"precision\\\"))\\n if prec == 0:\\n return \\\"f\\\"\\n else:\\n return \\\".{0}f\\\".format(prec)\",\n \"def getSize(self, precision=1):\\n kilo = 1000.0\\n if self.size < kilo:\\n return str(self.size) + \\\"B\\\"\\n elif self.size < kilo ** 2:\\n return str(round(self.size / kilo, precision)) + \\\"K\\\"\\n elif self.size < kilo ** 3:\\n return str(round(self.size / (kilo ** 2), precision)) + \\\"M\\\"\\n elif self.size < kilo ** 4:\\n return str(round(self.size / (kilo ** 3), precision)) + \\\"G\\\"\\n else:\\n return str(round(self.size / (kilo ** 4), precision)) + \\\"T\\\"\",\n \"def unit_of_measurement(self) -> str:\\n return MS\",\n \"def unit_of_measurement(self):\\r\\n return self._sensor_cfg[1]\",\n \"def unit_of_measurement(self):\\r\\n return self._sensor_cfg[1]\",\n \"def get_observed_precision(self):\\n return self.get_precision()\",\n \"def unit_of_measurement(self) -> str:\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self.device.unit()\",\n \"def unit_of_measurement(self):\\n return self._config.get(CONF_UNIT_OF_MEASUREMENT)\",\n \"def unit_of_measurement(self) -> str:\\n return self._unit\",\n \"def GetTimePrecision():\\n return _gmat_py.GmatBase_GetTimePrecision()\",\n \"def unit_of_measurement(self):\\n return self.sensor_type[\\\"unit\\\"]\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._unit\",\n \"def unit_of_measurement(self):\\n return self._unit\",\n \"def unit_of_measurement(self):\\n return self._unit\",\n \"def unit_of_measurement(self):\\n return self._unit\",\n \"def unit_of_measurement(self):\\n return self._unit\",\n \"def unit_of_measurement(self):\\n return self._unit\",\n \"def unit_of_measurement(self):\\n return self._unit\",\n \"def unit_of_measurement(self):\\n return self.var_units\",\n \"def unit_of_measurement(self):\\n return self._var_unit\",\n \"def unit_of_measurement(self):\\n return self._var_unit\",\n \"def units(self, size=\\\"G\\\", transfer='GB/s'): # YAML\",\n \"def us(self):\\n return 1000 * 1000 * self.read()\",\n \"def get_precision(self):\\n config_str = self.raw_sensor_strings[1].split()[4] # Byte 5 is the config register\\n bit_base = int(config_str, 16) >> 5 # Bit 5-6 contains the resolution, cut off the rest\\n return bit_base + 9 # min. is 9 bits\",\n \"def unit_of_measurement(self):\\n return self._sensor.unit\",\n \"def precision(self) :\\n return self.__precision\",\n \"def precision(self) :\\n return self.__precision\",\n \"def GmatBase_GetTimePrecision():\\n return _gmat_py.GmatBase_GetTimePrecision()\",\n \"def test_get_std(self):\\n\\n std = self.info_list.get_std()\\n self.assertEqual(std, 111.08728376994648)\",\n \"def native_unit_of_measurement(self):\\n return self._unit_of_measurement\",\n \"def unit_of_measurement(self):\\n return self._sensor_type.unit\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES[self.sensor][1]\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES[self.variable][1]\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES[self.variable][1]\",\n \"def get_std(self):\\n return self.serie.std()\",\n \"def _get_precision(self) -> float:\\n precicions = [PRECISION_WHOLE, PRECISION_HALVES, PRECISION_TENTHS]\\n static_info = self._static_info\\n if static_info.visual_current_temperature_step != 0:\\n step = static_info.visual_current_temperature_step\\n else:\\n step = static_info.visual_target_temperature_step\\n for prec in precicions:\\n if step >= prec:\\n return prec\\n # Fall back to highest precision, tenths\\n return PRECISION_TENTHS\",\n \"def unit_of_measurement(self) -> Any:\\n return PERCENTAGE\",\n \"def unit_of_measurement(self):\\n if self._xfinity_data.unit is not None:\\n return self._xfinity_data.unit\",\n \"def precision(self, s=''):\\n ptformatter = self.shell.display_formatter.formatters['text/plain']\\n ptformatter.float_precision = s\\n return ptformatter.float_format\",\n \"def unit_of_measurement(self):\\n return self._units\",\n \"def unit_of_measurement(self):\\n return self.display_currency\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES[self._type][2]\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES[self._type][2]\",\n \"def unit_of_measurement(self):\\n return None\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES[self.type][1]\",\n \"def precision(self):\\n string = self.ask('od;E;') # get the actual output\\n i1 = string.find('.')\\n # find the indices of the dot before the decimal part and the E before\\n # the exponent\\n i2 = string.find('E', i1)\\n # calculate the number of digit in the decimal part\\n decimals = i2 - i1 - 1\\n exponent = int(string[i2 + 1:])\\n prec = 10**(-decimals + exponent) # calculate te precision\\n return prec\",\n \"def getUnits(self):\\n return _libsbml.Parameter_getUnits(self)\",\n \"def get_gsize(self):\\n gsize_file = Genome(self.genome).get_fasize()\\n gsize = 0\\n with open(gsize_file, 'rt') as fi:\\n for a in fi:\\n c, n = a.strip().split('\\\\t')\\n gsize += int(n)\\n return gsize\",\n \"def result(self):\\n return (\\\"Precision@\\\" + str(self.length) + \\\": \\\"), (self.hit / self.test)\",\n \"def unit_of_measurement(self):\\n return UNIT_GALLONS_PER_MINUTE\",\n \"def unit_of_measurement(self):\\n return self.values.primary.units\",\n \"def unit(self):\\n return self._unit\",\n \"def GetTransformPrecision(self):\\n return _itkSpatialObjectWriterPython.itkSpatialObjectWriter2_GetTransformPrecision(self)\",\n \"def get_units(self,):\\n self.UNITS = {'pressure':'Pa',}\\n return\",\n \"def unit_of_measurement(self):\\n return SENSOR_UNITS.get(self._sensor_name, None)\",\n \"def unit_of_measurement(self):\\n return SENSOR_UNITS.get(self._sensor_name, None)\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES[self._type][1]\",\n \"def get_units(self):\\n return str(self._modeler.GetModelUnits())\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES[self._sensor][0]\",\n \"def unit_of_measurement(self):\\n return LENGTH_METERS\",\n \"def get_unit(self):\\n return self.unit\",\n \"def _get_units(self):\\n #assert self.ser.isOpen()\\n\\n self.serial_connection.write('UNI' + self.CR + self.LF)\\n acknowledgement = self.serial_connection.readline()\\n self._check_acknowledgement(acknowledgement)\\n\\n self.serial_connection.write(self.ENQ)\\n unit = self.MEASUREMENT_UNITS[self.serial_connection.readline().rstrip(self.LF).rstrip(self.CR)]\\n\\n self.serial_connection.write(self.CR + self.LF)\\n\\n return unit\",\n \"def prec(self):\\n return self._prec\",\n \"def prec(self):\\n return self._prec\",\n \"def getTimeUnits(self):\\n return _libsbml.KineticLaw_getTimeUnits(self)\",\n \"def unit_of_measurement(self):\\n return self._tasmota_entity.unit\",\n \"def unit_of_measurement(self):\\n return '%'\",\n \"def get_grating_lines_per_mm(self):\\r\\n msg = struct.pack('>2B', 56, 2)\\r\\n response = self.query(msg)\\r\\n return struct.unpack('>H', response[:2])[0]\",\n \"def totalUnits(self):\\n\\t\\treturn self.units\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES.get(self._sensor_type)[1]\",\n \"def unit_of_measurement(self):\\n return SENSOR_TYPES.get(self._sensor_type)[1]\",\n \"def unit_of_measure(self):\\n try:\\n uom = self.metadata['geosoft']['dataset']['geo:unitofmeasurement']['#text']\\n except KeyError:\\n uom = ''\\n return uom\",\n \"def unit_of_measurement(self):\\n\\n if self._sensor_class == DEVICE_CLASS_TEMPERATURE:\\n return TEMP_CELSIUS\\n\\n elif self._sensor_class == DEVICE_CLASS_HUMIDITY:\\n return '%'\",\n \"def unit_of_measurement(self):\\n return self.temperature_unit\",\n \"def get_numerical_repr(self):\\r\\n return \\\"%s\\\\t%s\\\\t%.2f\\\\n\\\" % (self.trf_period,\\r\\n self.trf_array_length,\\r\\n self.trf_array_gc)\",\n \"def precision(self):\\n return PRECISION_WHOLE\",\n \"def get_precision(TP, FP):\\n precision = TP / (TP + FP)\\n return precision\",\n \"def GetTransformPrecision(self):\\n return _itkSpatialObjectWriterPython.itkSpatialObjectWriter3_GetTransformPrecision(self)\",\n \"def getProfileSize(self):\\n return convToUnits(self.profileBytes, divby=1000)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66406333","0.62469673","0.62469673","0.62245446","0.6159991","0.6155099","0.6046847","0.60281473","0.60199654","0.597692","0.597692","0.5961308","0.5957242","0.59303707","0.59269","0.5922502","0.5920388","0.58822894","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5881604","0.5873649","0.5873649","0.5873649","0.5873649","0.5873649","0.5873649","0.5873649","0.5870074","0.58628464","0.58628464","0.5860167","0.58458996","0.5835284","0.5828001","0.5824953","0.5824953","0.5818948","0.5797677","0.57901025","0.57840854","0.5765767","0.57648456","0.57648456","0.5761584","0.57520187","0.5721151","0.57200426","0.5702574","0.5694106","0.56835","0.5656809","0.5656809","0.5655531","0.5652146","0.5631291","0.5621497","0.5608227","0.5602876","0.55996174","0.5583351","0.55829597","0.55754465","0.5574926","0.5566409","0.5566409","0.5558575","0.55529934","0.5552583","0.5542048","0.5531922","0.55140567","0.5513927","0.5513927","0.55133975","0.5513161","0.55128145","0.55117166","0.5510684","0.5505208","0.5505208","0.5500605","0.5495324","0.5490874","0.5479153","0.54723513","0.5467583","0.5465881","0.5465202"],"string":"[\n \"0.66406333\",\n \"0.62469673\",\n \"0.62469673\",\n \"0.62245446\",\n \"0.6159991\",\n \"0.6155099\",\n \"0.6046847\",\n \"0.60281473\",\n \"0.60199654\",\n \"0.597692\",\n \"0.597692\",\n \"0.5961308\",\n \"0.5957242\",\n \"0.59303707\",\n \"0.59269\",\n \"0.5922502\",\n \"0.5920388\",\n \"0.58822894\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5881604\",\n \"0.5873649\",\n \"0.5873649\",\n \"0.5873649\",\n \"0.5873649\",\n \"0.5873649\",\n \"0.5873649\",\n \"0.5873649\",\n \"0.5870074\",\n \"0.58628464\",\n \"0.58628464\",\n \"0.5860167\",\n \"0.58458996\",\n \"0.5835284\",\n \"0.5828001\",\n \"0.5824953\",\n \"0.5824953\",\n \"0.5818948\",\n \"0.5797677\",\n \"0.57901025\",\n \"0.57840854\",\n \"0.5765767\",\n \"0.57648456\",\n \"0.57648456\",\n \"0.5761584\",\n \"0.57520187\",\n \"0.5721151\",\n \"0.57200426\",\n \"0.5702574\",\n \"0.5694106\",\n \"0.56835\",\n \"0.5656809\",\n \"0.5656809\",\n \"0.5655531\",\n \"0.5652146\",\n \"0.5631291\",\n \"0.5621497\",\n \"0.5608227\",\n \"0.5602876\",\n \"0.55996174\",\n \"0.5583351\",\n \"0.55829597\",\n \"0.55754465\",\n \"0.5574926\",\n \"0.5566409\",\n \"0.5566409\",\n \"0.5558575\",\n \"0.55529934\",\n \"0.5552583\",\n \"0.5542048\",\n \"0.5531922\",\n \"0.55140567\",\n \"0.5513927\",\n \"0.5513927\",\n \"0.55133975\",\n \"0.5513161\",\n \"0.55128145\",\n \"0.55117166\",\n \"0.5510684\",\n \"0.5505208\",\n \"0.5505208\",\n \"0.5500605\",\n \"0.5495324\",\n \"0.5490874\",\n \"0.5479153\",\n \"0.54723513\",\n \"0.5467583\",\n \"0.5465881\",\n \"0.5465202\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6897266"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":164,"numItemsPerPage":100,"numTotalItems":95772,"offset":16400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjE3NTA0MCwianRpIjoiNTc4NmRhMTMtZDZhZC00Y2YwLTliNTktMTQ4Y2YzMDc4YjRjIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYxNzg2NDAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.RGznwK29DDE_OoKnvWP0LXT69o4trcbaWT4701pUxKST0Pquup6c_nkDNjXoOtoagSuHd_tWuyeeozaNGnkbDQ","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 |
|---|---|---|---|---|---|---|
initialize the MarketSegment instance | def __init__(self, name, accounts=None):
self.name = name
if accounts:
self._accounts = accounts
for account in accounts:
# add_account_to_ms is False because we've already added the
# account to this segment, don't want to do it again
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def construct_segment(self):\n segment = Segment(\n model_id = self.model_id,\n chain_id = self.chain_id)\n\n segment.chain = self.chain\n segment.model = self.model\n\n return segment",
"def construct_segment(self):\n segment = Segment(\n model... | [
"0.6190421",
"0.6095966",
"0.60732186",
"0.5757404",
"0.5754233",
"0.5752619",
"0.57325923",
"0.5704366",
"0.5683267",
"0.5670845",
"0.56523126",
"0.56402427",
"0.56402427",
"0.5637231",
"0.563603",
"0.5632467",
"0.56236625",
"0.56236625",
"0.56236625",
"0.56236625",
"0.56236... | 0.5701224 | 8 |
provide functionality to associate an account with the market segment Raises ValueError if the market segment already knows about the account | def add_account(self, account, add_ms_to_account=True):
# check if name already exists and throw ValueError if it does
# it doesn't make sense to add an account twice -- this could be
# refactored to use a set instead
# check for accounts by name per Q2 bonus below
if accoun... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put_account(self, account):\n \n pass",
"def associate_member_account(memberAccountId=None):\n pass",
"def add_account(insert_dict):\n return ar.add_account(insert_dict)",
"def add_account(self, account):\n self.accounts[account.account_number] = account.json()\n # We sh... | [
"0.6881962",
"0.6379945",
"0.6314283",
"0.6247812",
"0.614936",
"0.614936",
"0.6070196",
"0.6060519",
"0.60320276",
"0.59797066",
"0.5976318",
"0.58752096",
"0.586902",
"0.5846821",
"0.5827182",
"0.5821246",
"0.57961375",
"0.5756492",
"0.5755137",
"0.5746932",
"0.57255113",
... | 0.6542094 | 1 |
disassociate the account from this MarketSegment | def remove_account(self, account, remove_ms_from_account=True):
# check for accounts by name per Q2 bonus below
if account.name in [account.name for account in self._accounts]:
self._accounts.remove(account)
if remove_ms_from_account:
account.remove_from_mark... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disassociate_member_account(memberAccountId=None):\n pass",
"def delete_account(self, account):\n \n pass",
"def delete_account(self):\n Credential.account_list.remove(self)",
"def remove_from_market_segment(self, market_segment):\r\n if market_segment in self._market_segme... | [
"0.72093874",
"0.6797859",
"0.6363812",
"0.6213715",
"0.6171504",
"0.6040757",
"0.5929909",
"0.58401936",
"0.5739876",
"0.56988853",
"0.5573408",
"0.5563919",
"0.5554293",
"0.5497242",
"0.54905313",
"0.5477191",
"0.54696035",
"0.5433291",
"0.54182625",
"0.5360094",
"0.5357016... | 0.63674426 | 2 |
get the accounts associated with this MarketSegment | def get_accounts(self):
return self._accounts | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_accounts(self):\n return self.accounts",
"def accounts(self):\n return self._accounts.values()",
"def get_accounts(self):\n return self.accounts.all()",
"def get_accounts(self):\n\n\t\treturn self.__accounts",
"def accounts(self):\r\n return acc.Accounts(self)",
"def G... | [
"0.7349792",
"0.7301584",
"0.7274265",
"0.72648835",
"0.69971514",
"0.69915533",
"0.6787148",
"0.67281044",
"0.6724366",
"0.6685089",
"0.6642747",
"0.6617825",
"0.6611883",
"0.6562705",
"0.65290934",
"0.6513251",
"0.650435",
"0.64825416",
"0.6427938",
"0.6316828",
"0.62958187... | 0.7285145 | 2 |
setup this instance of Account | def __init__(self, name, sales_rep=None, market_segments=None):
self.name = name
self._sales_rep = sales_rep
self._children = []
if market_segments:
self._market_segments = market_segments
for market_segment in market_segments:
# add_ms_to_a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, account, user_username, user_password):\n self. account = account\n self. user_username = user_username\n self.user_password = user_password",
"def __init__(self,Account,username,password):\n self.Account = Account\n self.username = username\n self.pas... | [
"0.7074514",
"0.6964193",
"0.69499296",
"0.69038534",
"0.6841956",
"0.6841956",
"0.6841956",
"0.6841956",
"0.68143064",
"0.6808298",
"0.6769417",
"0.6767063",
"0.67506003",
"0.6694272",
"0.66941416",
"0.66868305",
"0.6663654",
"0.66210026",
"0.6554672",
"0.6512321",
"0.650264... | 0.0 | -1 |
get the sales rep assocated to this Account | def get_sales_rep(self):
return self._sales_rep | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sales_rep_code(self):\n return self._sales_rep_code",
"def get_sales_data():\n print(\"Retrieving all the sales information...\")\n data = SHEET.worksheet('sales')\n print(\"Compilation complete!\\n\")\n return data",
"def get_sales(res=None, user_email=None, user_role=None, user_id=None... | [
"0.60808676",
"0.59343404",
"0.5843296",
"0.58057",
"0.5775382",
"0.57279",
"0.5499945",
"0.5478197",
"0.5337665",
"0.53167444",
"0.53152895",
"0.5267397",
"0.5243935",
"0.52410465",
"0.52232355",
"0.52158624",
"0.52153754",
"0.52091914",
"0.5116701",
"0.5112952",
"0.511263",... | 0.7881946 | 0 |
set the sales rep for this Account | def set_sales_rep(self, sales_rep):
self._sales_rep = sales_rep | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sales(self, sales):\n\n self._sales = sales",
"def get_sales_rep(self):\r\n return self._sales_rep",
"def sales_rep_code(self, sales_rep_code):\n if sales_rep_code is not None and len(sales_rep_code) > 10:\n raise ValueError(\"Invalid value for `sales_rep_code`, length must ... | [
"0.71684736",
"0.60573095",
"0.5699982",
"0.55540127",
"0.5448541",
"0.5195966",
"0.5159155",
"0.51239115",
"0.5077749",
"0.5022728",
"0.49740148",
"0.49725026",
"0.49634492",
"0.4955389",
"0.4955389",
"0.49489853",
"0.49296564",
"0.49223012",
"0.49128014",
"0.49119002",
"0.4... | 0.81403697 | 0 |
replaces the list of market segments for this Account | def set_market_segments(self, segments):
"""
Q1-2. Implement this method, which takes an iterable of MarketSegments
to which this Account will be attached. This method REPLACES all
MarketSegment associations, so be sure to update each
MarketSegment's intern... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_from_market_segment(self, market_segment):\r\n if market_segment in self._market_segments:\r\n self._market_segments.remove(market_segment)\r\n market_segment.remove_account(self)\r\n else:\r\n # nothing to do, the market segment was already\r\n ... | [
"0.5418846",
"0.5301822",
"0.4919815",
"0.48922998",
"0.48700333",
"0.4845712",
"0.48402044",
"0.479326",
"0.47908777",
"0.4755174",
"0.47279075",
"0.47138822",
"0.46888635",
"0.46419635",
"0.46125323",
"0.45995706",
"0.45915312",
"0.4556438",
"0.45542613",
"0.45532054",
"0.4... | 0.7383106 | 0 |
add a market segment to this account | def add_to_market_segment(self, market_segment, add_account_to_ms=True):
if market_segment in self._market_segments:
raise ValueError("{name} already part of {ms_name}"
.format(name=self.name,
ms_name=market_segment.name))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_market_segments(self, segments):\r\n \"\"\"\r\n Q1-2. Implement this method, which takes an iterable of MarketSegments\r\n to which this Account will be attached. This method REPLACES all\r\n MarketSegment associations, so be sure to update each\r\n Mark... | [
"0.65802324",
"0.6395969",
"0.61662567",
"0.6164237",
"0.5980403",
"0.5974769",
"0.5835148",
"0.5825939",
"0.5788526",
"0.5769048",
"0.5765961",
"0.5738792",
"0.572644",
"0.57032543",
"0.5656395",
"0.5605565",
"0.54737425",
"0.5466607",
"0.543837",
"0.5411004",
"0.5402753",
... | 0.73550326 | 0 |
remove the market segment from this account | def remove_from_market_segment(self, market_segment):
if market_segment in self._market_segments:
self._market_segments.remove(market_segment)
market_segment.remove_account(self)
else:
# nothing to do, the market segment was already
# not in the acco... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_account(self, account, remove_ms_from_account=True):\r\n # check for accounts by name per Q2 bonus below\r\n if account.name in [account.name for account in self._accounts]:\r\n self._accounts.remove(account)\r\n if remove_ms_from_account:\r\n account.r... | [
"0.6916367",
"0.6139307",
"0.6004958",
"0.5911972",
"0.58914524",
"0.5845003",
"0.58389115",
"0.57946837",
"0.5777495",
"0.57668144",
"0.57654405",
"0.5762761",
"0.5756127",
"0.57521224",
"0.57489353",
"0.5699705",
"0.56938523",
"0.56938523",
"0.5637024",
"0.5632075",
"0.5620... | 0.8205841 | 0 |
helper function that returns market segments in a list | def get_market_segments(self):
return self._market_segments | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def segments(self):\n return (self._subset((i,i+1)) for i in range(len(self)-1))",
"def getSegments(self) -> List[int]:\n ...",
"def segment(raw_sents:List[str], segment=\"jieba\") -> List[List[str]]:\n\t# segment_list = [\"pkuseg\", \"jieba\"]\n\t# if segment.strip() not in segment_list:\n\t# \t... | [
"0.61199504",
"0.6006646",
"0.58567095",
"0.58383083",
"0.5830448",
"0.5721447",
"0.5628691",
"0.5575491",
"0.55676895",
"0.5562992",
"0.55484986",
"0.5547066",
"0.55222625",
"0.5482955",
"0.54704505",
"0.54665774",
"0.54454684",
"0.54365534",
"0.5432282",
"0.5424745",
"0.541... | 0.6885291 | 0 |
associates an instance of ChildAccount to this Account | def add_child(self, child_account):
self._children.append(child_account) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_account(self):\n Credential.account_list.append(self)",
"def add(self, account):\n if isinstance(account, Account) and account not in self.account:\n self.account.append(account)",
"def put_account(self, account):\n \n pass",
"def account(self, account):\n\n ... | [
"0.6679163",
"0.6542428",
"0.6518352",
"0.64333874",
"0.64333874",
"0.64333874",
"0.64333874",
"0.6373562",
"0.63151264",
"0.62300396",
"0.6036437",
"0.6035886",
"0.599156",
"0.59576416",
"0.59400326",
"0.59400326",
"0.5933551",
"0.5873395",
"0.5868553",
"0.58684623",
"0.5868... | 0.6822193 | 0 |
get the list of children (if any) for this account | def get_children(self):
return self._children | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_children(self):\n return self.children",
"def get_children(self):\n return self.children",
"def get_children(self):\n return self.children",
"def get_children(self):\r\n return self.children",
"def get_children(self):\n return []",
"def get_children(self):\n\n ... | [
"0.7708436",
"0.7708436",
"0.7708436",
"0.7692462",
"0.75784594",
"0.75485694",
"0.7512054",
"0.7490745",
"0.74791145",
"0.7350118",
"0.7291376",
"0.7291189",
"0.7266678",
"0.7260878",
"0.7260878",
"0.72332436",
"0.7230133",
"0.7148525",
"0.709136",
"0.7063422",
"0.7047157",
... | 0.7514173 | 6 |
print a hierarchical structure representing an account and all child accounts associated to it to the console | def print_tree(account, level=0):
""" In the example output below, "GE" is the root account, "Jet Engines"
and "Appliances" are first-degree ChildAccounts, and "DoD Contracts"
and "Washing Machines" are second-degree ChildAccounts.
> print_tree(general_electric)
GE (Manufacturing, R&D... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_tree(self):\n\t\tprint(self.__print_tree('', True, ''))",
"def print_recursive(self, indents):\n\n\t\tind = \"\\t\"\n\t\toutput = indents * ind + self.name\n\t\tprint(output)\n\t\tfor i in self.children:\n\t\t\ti.print_recursive(indents+1)",
"def print_account(account):\r\n markets_output = \"\"\r... | [
"0.65483695",
"0.6483711",
"0.64607173",
"0.63137734",
"0.62994003",
"0.6192441",
"0.6160616",
"0.6061901",
"0.60491484",
"0.60221314",
"0.6008796",
"0.6002482",
"0.6001772",
"0.5992742",
"0.598194",
"0.59669787",
"0.59571195",
"0.59471905",
"0.59323215",
"0.589066",
"0.58874... | 0.77148306 | 0 |
not functionaly needed, but was used for debugging purposes, prints a simple one line representation of an account, but no children | def print_account(account):
markets_output = ""
for market in account.get_market_segments():
markets_output += market.name.strip("\'") + ", "
markets_output = markets_output.strip("\'")
print(f'{account.name} ({markets_output[:-2]}): {account.get_sales_rep()}') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_tree(account, level=0):\r\n \"\"\" In the example output below, \"GE\" is the root account, \"Jet Engines\"\r\n and \"Appliances\" are first-degree ChildAccounts, and \"DoD Contracts\"\r\n and \"Washing Machines\" are second-degree ChildAccounts.\r\n\r\n > print_tree(general_electric)... | [
"0.6965512",
"0.68350005",
"0.6194999",
"0.61706173",
"0.61338204",
"0.60519546",
"0.59987116",
"0.5957116",
"0.5939303",
"0.5916133",
"0.5865019",
"0.5812702",
"0.58114535",
"0.57372445",
"0.5722173",
"0.5700545",
"0.56958437",
"0.5687173",
"0.5681779",
"0.5672956",
"0.56630... | 0.6467906 | 2 |
utility function that checks the global scope for an object that matches the one passed in, if it doesn't exist create the reference in the global scope, this allows for "anonymous" object creation and to still get the object back later Note, the new object name will be the name property with special characters removed... | def check_for_existing_market_segment(segment):
for var in list(globals().keys()):
if isinstance(eval("{var}".format(var=var)), MarketSegment):
if eval("{var}.name".format(var=var)) == segment.name:
return
# no matching segment found in globals, create it!
var_nam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default_object_scoper(object_name):\n return \"tag=\\\"{}\\\"\".format(object_name)",
"def create_object(object_name):\n if object_name == 'deathstar':\n return Deathstar()\n elif object_name == 'mercury':\n return Mercury()\n elif object_name == 'venus':\n ... | [
"0.58888537",
"0.58255064",
"0.57960576",
"0.5781576",
"0.5686544",
"0.5686237",
"0.5602739",
"0.55378485",
"0.5523215",
"0.54923826",
"0.544969",
"0.5409906",
"0.5392193",
"0.5361912",
"0.5337955",
"0.5288816",
"0.52435946",
"0.5224719",
"0.52194655",
"0.5201718",
"0.5197779... | 0.6119238 | 0 |
Basically any speaker id is valid. | def clean(self, value):
speakers = speaker_models.Speaker.objects.filter(pk__in=value)
if len(speakers) != len(value):
raise ValidationError(self.error_messages['invalid_choice'] % value)
return speakers | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_api_invalid_stream_id(self) -> None:\n user = self.example_user(\"hamlet\")\n self.login_user(user)\n result = self.api_patch(\n user,\n \"/api/v1/users/me/subscriptions/121\",\n {\"property\": \"is_muted\", \"value\": \"somevalue\"},\n )\n ... | [
"0.5956092",
"0.59091747",
"0.5825499",
"0.56224096",
"0.5605519",
"0.5577106",
"0.5576042",
"0.5531081",
"0.5529223",
"0.5528064",
"0.55078095",
"0.55064124",
"0.5498113",
"0.5472017",
"0.54554164",
"0.54426545",
"0.54162496",
"0.54084516",
"0.53983134",
"0.5389476",
"0.5380... | 0.59182245 | 1 |
validation is in eval mode so we do not have to use placeholder input tensors | def validation_step(self, batch, batch_idx):
src_batch, trg_batch = batch
src_seq = src_batch["src_ids"]
# change from [batch, seq_len] -> to [seq_len, batch]
src_seq = src_seq.transpose(0, 1)
src_lengths = src_batch["src_lengths"]
trg_seq = trg_batch["trg_ids"]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def linear_eval(train_ds, model, task, epochs=10, eval_ds=None):\n\n print('==========LINEAR EVAL==========')\n\n # Filter out undesired examples with excluded_label\n ds = train_ds.filter(lambda x: x['label'] != task['excluded_label'])\n ds = ds.map(data_utils.finetune_preprocess)\n ds = ds.shuffle... | [
"0.71973443",
"0.7176972",
"0.71241623",
"0.7115858",
"0.697105",
"0.6960811",
"0.67767024",
"0.67586493",
"0.6738238",
"0.66192645",
"0.6600604",
"0.65923727",
"0.65843695",
"0.65088737",
"0.65082693",
"0.6502381",
"0.6492778",
"0.649229",
"0.6491189",
"0.64898956",
"0.64866... | 0.0 | -1 |
Extract names of categorical column This function accepts a dataframe and returns categorical list, containing the names of categorical columns(categorical_var). | def categorical(df):
categorical_var=df.select_dtypes(include ='object').columns.tolist()
return categorical_var | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_categorical(X):\n return list(X.columns[X.dtypes == \"object\"])",
"def find_cats(column):\r\n return pd.Categorical(column).categories",
"def find_categorical(self, df):\n# print(type(df),df.ndim)\n categorical = [key for key in df.keys() if df.dtypes[key] == np.dtype('O')]\n ... | [
"0.76022893",
"0.73164177",
"0.721496",
"0.721496",
"0.71881354",
"0.7059722",
"0.7012867",
"0.68130624",
"0.6789028",
"0.6767523",
"0.6670025",
"0.66088444",
"0.65843177",
"0.65426064",
"0.647856",
"0.6408604",
"0.63178056",
"0.62948096",
"0.6281347",
"0.6274706",
"0.6269459... | 0.8474346 | 0 |
Extract names of numerical column This function accepts a dataframe and returns numerical list, containing the names of numerical columns(numerical_var). | def numerical(df):
numerical_var=df.select_dtypes(include =['float64','int64']).columns.tolist()
return numerical_var | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_values(df):\n return df.columns.values.tolist()",
"def get_non_num_cols(df):\n numerics = ['number']\n newdf = df.select_dtypes(exclude=numerics).columns\n return newdf",
"def get_numerical_columns(\n data_frame: pd.DataFrame,\n ignore_columns: list = [],\n uniqueness_thresshold: O... | [
"0.69793",
"0.6972095",
"0.6884711",
"0.68393546",
"0.68223983",
"0.6716611",
"0.6578074",
"0.65518904",
"0.6534117",
"0.65030515",
"0.6406427",
"0.6395277",
"0.6376944",
"0.6354434",
"0.63127095",
"0.62207276",
"0.6156436",
"0.61465174",
"0.6141555",
"0.6123878",
"0.6118097"... | 0.81623864 | 0 |
Check distribution of variable This function accepts a dataframe,column(feature) and value which returns count of the value, containing the value counts of a variable(value_counts) | def clear(df,col,val):
value_counts=df[col][df[col]==val].count()
return value_counts | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def value_frequencies(df, column):\n\n df_val = pd.DataFrame(df[column].value_counts())\n df_val = df_val.rename(columns={column: \"Count\"})\n df_val[\"Frequency\"] = df_val[\"Count\"] / len(df) * 100\n return df_val",
"def obj_value_counts(df):\n df_obj = obj_df(df)\n for col in df_obj.column... | [
"0.6731079",
"0.6531181",
"0.6249982",
"0.6218801",
"0.61668086",
"0.61371034",
"0.6032908",
"0.59703606",
"0.59183574",
"0.5821373",
"0.5811538",
"0.5804806",
"0.58035743",
"0.5792839",
"0.5758376",
"0.57148397",
"0.5679529",
"0.5673475",
"0.5659964",
"0.5651597",
"0.5651446... | 0.5627474 | 21 |
Instances based on the condition This function accepts a dataframe, 2 columns(feature) and 2 values which returns the dataframe based on the condition. | def instances_based_condition(df,col1,val1,col2,val2):
instance=df[(df[col1]>val1) & (df[col2]==val2)]
return instance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_features(\r\n df:pd.DataFrame,\r\n path_data_dir:str\r\n ) -> pd.DataFrame:\r\n # Check input.\r\n # Copy dataframe to avoid in place modification.\r\n df = df.copy()\r\n # Check file path.\r\n if not os.path.exists(path_data_dir):\r\n raise IOError(textwrap.dedent(\"\"\"\... | [
"0.6037674",
"0.6036051",
"0.60075384",
"0.5784221",
"0.5742433",
"0.572674",
"0.56658465",
"0.5660512",
"0.5627629",
"0.55905753",
"0.5539647",
"0.55276555",
"0.55015665",
"0.5474494",
"0.5460671",
"0.54350704",
"0.54293996",
"0.54264325",
"0.5407314",
"0.53973925",
"0.53973... | 0.6541016 | 0 |
Aggregate values according to month This function accepts a dataframe, 2 columns(feature) and aggregated funcion(agg) which returns the Pivot table with different aggregated value of the feature with an index of the month. | def agg_values_ina_month(df,date_col,agg_col, agg):
df[date_col] = pd.to_datetime(df[date_col])
aggregate = {'mean':np.mean,'max':np.max,'min':np.min,'sum':np.sum,'len':len}
aggregated_value = df.pivot_table(values=[agg_col], index=df[date_col].dt.month,aggfunc={agg_col:aggregate[agg]})
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def month_summary(phenology_df, out_csv=None):\n month_list = ['Jul','Aug','Sep','Oct','Nov','Dec','Jan','Feb','Mar','Apr',\n 'May','Jun']\n species_list = phenology_df['species'].unique().tolist()\n\n count_list = []\n for species in species_list:\n count_dict = {'species':speci... | [
"0.5653905",
"0.56239855",
"0.5513427",
"0.5429735",
"0.5405292",
"0.540336",
"0.5373406",
"0.53479385",
"0.5302161",
"0.5241061",
"0.5224448",
"0.51862144",
"0.51552224",
"0.51262534",
"0.5092144",
"0.50751626",
"0.50463194",
"0.5034887",
"0.5023972",
"0.5020303",
"0.5016048... | 0.75534564 | 0 |
Agrregate values by grouping This function accepts a dataframe, 1 column(feature) and aggregated function(agg1) which groupby the datframe based on the column. | def group_values(df,col1,agg1):
grouping=df.groupby(col1).agg(agg1)
return grouping | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def agg(self, arg):\n # DataFrame{'a': [1, 1, 2], 'b': [1, 2, 3], 'c': [2, 2, 1]})\n # a.groupby('a').agg('sum') -- applied on rest\n # a.groupby('a').agg(['sum', 'min']) -- both applied on rest\n # a.groupby('a').agg({'b': ['min', 'mean']}) -- applied on\n # TODO\n # a.gr... | [
"0.62384295",
"0.62365556",
"0.6115062",
"0.57873046",
"0.5756204",
"0.5695222",
"0.56700325",
"0.56446403",
"0.5633193",
"0.56284815",
"0.5598864",
"0.55967784",
"0.55186844",
"0.5475055",
"0.54412466",
"0.53967935",
"0.5389561",
"0.5328148",
"0.53219986",
"0.5310613",
"0.53... | 0.74227715 | 0 |
Convert temperatures from celsius to fahrenhheit This function accepts a dataframe, 1 column(feature) which returns the dataframe with converted values from celsius to fahrenhheit. | def convert(df,celsius):
converted_temp=(df[celsius]*(9/5))+32
return converted_temp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_f_to_c(temp_in_farenheit): ## ##\n celsiustemp = round((temp_in_farenheit - 32) * 5/9, 1) ##\n return celsiustemp ##",
"def convert_celsius_to_fahre... | [
"0.6405321",
"0.63570726",
"0.63089514",
"0.6282194",
"0.624191",
"0.6216791",
"0.6167246",
"0.6161009",
"0.6136985",
"0.6065306",
"0.60189754",
"0.59730244",
"0.59621197",
"0.5952359",
"0.5952359",
"0.5928877",
"0.5866788",
"0.5863079",
"0.5858934",
"0.58513784",
"0.584079",... | 0.6762713 | 0 |
Parsing arguments for mix | def arg_parse():
parser = argparse.ArgumentParser()
parser.add_argument("-m", "--mix", required=False, help="cube shuffle")
parser.add_argument("-e", "--explain", action="store_true", help="Get more explanation about steps")
options = parser.parse_args()
return options | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def _parse_args(self, prepared_args):\n pass",
"def Args(parser):",
"def __parse_args(self):\n for argument in self.args:\n source_arg = re.match(\"^(--source=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n input_arg = re.match(\"^(--input=(([A-... | [
"0.78351986",
"0.68100625",
"0.6781909",
"0.67647475",
"0.6632456",
"0.6620455",
"0.6572196",
"0.64941555",
"0.64838773",
"0.64729136",
"0.6428082",
"0.63948846",
"0.6353774",
"0.6346599",
"0.6345576",
"0.63345915",
"0.62920505",
"0.62681496",
"0.6227157",
"0.6197175",
"0.615... | 0.6168493 | 20 |
Append a list after a first one | def append_list(lst_moves, to_add):
for elem in to_add:
lst_moves.append(elem)
return lst_moves | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_first(self, value):\n self.__list = [value] + self.__list\n return self.__list",
"def mutate_list_2(lst):\r\n elem = lst[0]\r\n lst.remove(elem)\r\n lst.append(elem)\r\n return lst",
"def following(lst, content):\n if content not in lst:\n return lst\... | [
"0.6928934",
"0.6246745",
"0.61780196",
"0.6156932",
"0.60925907",
"0.6074251",
"0.60594547",
"0.6018385",
"0.6012113",
"0.5947313",
"0.5900258",
"0.5896534",
"0.5895668",
"0.58403456",
"0.5837394",
"0.5836771",
"0.5824726",
"0.5822811",
"0.581092",
"0.5789515",
"0.5787964",
... | 0.0 | -1 |
Dump the population spike histogram values. | def dump_psth_peaks(ffname, outprefix, celltype, window=100e-3, binwidth=5e-3):
with open('{}_psth_{}_{}ms_window_{}ms_bins.csv'.format(outprefix, celltype, window*1e3, binwidth*1e3), 'wb') as fd:
writer = csv.writer(fd, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
dbcnt_flist = get_dbcn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _printHist(self):\n bins = [0] * self.displayBins\n binSize = self.maxValue / self.displayBins\n displaySamps = self.samples[:]\n displaySamps.sort()\n currLimit = binSize\n binIndex = 0\n partIndex = 0\n while partIndex < self.numParticles:\n ... | [
"0.6207578",
"0.61337715",
"0.61337715",
"0.58234936",
"0.5786558",
"0.5634706",
"0.559509",
"0.5576539",
"0.55664545",
"0.5549734",
"0.5505678",
"0.54868907",
"0.54738015",
"0.54414207",
"0.54130095",
"0.5407913",
"0.5359929",
"0.53546023",
"0.5333307",
"0.53166544",
"0.5276... | 0.57270867 | 5 |
returns true if strA divides strB | def divs(strA,strB):
for i in range(0,1001):
if strB == strA*i:
return(True)
return(False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_divisibility(a, b):\n \n float_version = float(a)/b\n int_version = a/b\n if float_version == int_version:\n answer = \"divisible\"\n else:\n answer = \"not divisible\"\n return answer",
"def call(str_a, str_b):\n if not sys.getsizeof(str_a) == sys.getsizeof(str_b... | [
"0.65836626",
"0.6551966",
"0.6452647",
"0.6091636",
"0.6034888",
"0.6031436",
"0.5918683",
"0.5906723",
"0.5901623",
"0.589791",
"0.5895614",
"0.58787555",
"0.5836668",
"0.5830642",
"0.58115834",
"0.5795731",
"0.5777818",
"0.5768081",
"0.5738433",
"0.5724008",
"0.57214195",
... | 0.80954874 | 0 |
Encode each string and check the encoding match | def isIsomorphic(s: str, t: str) -> bool:
def encode(s):
m = {}
r = []
for char in s:
if char not in m:
m[char] = len(m) # increasing index
r.append(m[char])
return str(r)
return encode(s) == encode(t) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode(self, strs):",
"def encode(self, strs):",
"def test_encode(self):\n for (input, output) in self.tests:\n self.assertEqual(input.encode('imap4-utf-7'), output)",
"def test_encode(self):\n pass # TODO(tlarsen)",
"def test_encode(self):\n assert url_encoder.encode(1... | [
"0.74811256",
"0.74811256",
"0.7096132",
"0.68377566",
"0.6790453",
"0.66363806",
"0.66236377",
"0.64748406",
"0.6461136",
"0.64332485",
"0.6391071",
"0.6373295",
"0.6354942",
"0.6241875",
"0.6189024",
"0.60329634",
"0.60249454",
"0.60169256",
"0.60166717",
"0.5977058",
"0.59... | 0.0 | -1 |
Followup, group isomorphic strings | def group_isomorphic(strs):
def encode(s):
r, d = [], {}
for c in s:
if c not in d:
d[c] = len(d)
r.append(d[c])
return str(r)
m = defaultdict(list)
for s in strs:
m[encode(s)].append(s)
return list(m.values()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def group_anagrams(strs):\n anagram_grouping = {}\n \n for anagram in strs:\n curr_ana = str(sorted(anagram))\n anagram_grouping.setdefault(curr_ana, [])\n \n anagram_grouping[curr_ana].append(anagram)\n \n return [ anagram_grouping[gro... | [
"0.60339314",
"0.58468187",
"0.5554626",
"0.5472503",
"0.54396987",
"0.5400801",
"0.53897846",
"0.537732",
"0.5353079",
"0.53035206",
"0.53021216",
"0.52842623",
"0.5275526",
"0.5262117",
"0.5258697",
"0.52123475",
"0.5208093",
"0.5203539",
"0.5198474",
"0.51681864",
"0.51431... | 0.7192948 | 0 |
Return processed audio data. Returns mel curve, x/y data. This method is called every time there is a microphone update. | def update(self, audio_samples):
min_frequency = self._config["general_settings"]["min_frequency"]
max_frequency = self._config["general_settings"]["max_frequency"]
audio_data = {}
# Normalize samples between 0 and 1.
y = audio_samples / 2.0**15
# Construct a rolling win... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readWaveform(self):\n # prepare data holder\n y = [ 0 for j in range(4) ]\n # in case of previous errors\n self.flushInput()\n for ch in self.chs:\n # mostly for TDS\n self.setCh(ch)\n # calibration factor we will need soon\n (vmult... | [
"0.6034653",
"0.59338874",
"0.5892915",
"0.5839982",
"0.5827902",
"0.57516843",
"0.574115",
"0.5740674",
"0.5702725",
"0.5690479",
"0.568213",
"0.56605065",
"0.5635295",
"0.56270736",
"0.5599267",
"0.5588864",
"0.5587347",
"0.5577383",
"0.5565157",
"0.55617267",
"0.55504036",... | 0.62964714 | 0 |
Small rise/decay factors = more smoothing. | def __init__(self, val=0.0, alpha_decay=0.5, alpha_rise=0.5):
assert 0.0 < alpha_decay < 1.0, 'Invalid decay smoothing factor.'
assert 0.0 < alpha_rise < 1.0, 'Invalid rise smoothing factor.'
self.alpha_decay = alpha_decay
self.alpha_rise = alpha_rise
self.value = val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lr_decay(step):\n return(alpha / (1 + decay_rate * step))",
"def step_decay(epoch):\n initial_lrate = 0.1\n drop = 0.5\n epochs_drop = 10.0\n lrate = initial_lrate * math.pow(drop, math.floor((1 + epoch) / epochs_drop))\n # print(f\"For epoch {epoch}, Learning rate is {lrate}\")... | [
"0.6954242",
"0.65860534",
"0.65200704",
"0.64522135",
"0.64373386",
"0.63609886",
"0.62818044",
"0.62043864",
"0.62007785",
"0.61982685",
"0.6193027",
"0.6169785",
"0.6165778",
"0.60895914",
"0.6014151",
"0.60004514",
"0.59806603",
"0.5980432",
"0.5980153",
"0.5978049",
"0.5... | 0.6290513 | 6 |
Returns melfrequency from linear frequency input. Parameter | def hertz_to_mel(self, freq):
return 3340.0 * log(1 + (freq / 250.0), 9) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mel_to_linear(frequency):\n return 700.0 * (np.exp(frequency / 1127.01048) - 1.0)",
"def linear_to_mel(frequency):\n return 1127.01048 * np.log(1.0 + frequency / 700.0)",
"def hz2mel(freq):\n return 2595. * np.log10(1+freq/700.0)",
"def hertz_to_mel(freq):\n return 2595.0 * np.log10(1 + (freq... | [
"0.76702917",
"0.7321775",
"0.68783236",
"0.6760246",
"0.67551947",
"0.6675257",
"0.656555",
"0.6558269",
"0.6518677",
"0.64406323",
"0.64313215",
"0.6396839",
"0.6381468",
"0.63540506",
"0.6313718",
"0.62764466",
"0.6267781",
"0.62511164",
"0.6245195",
"0.6216545",
"0.620624... | 0.6451159 | 9 |
Returns frequency from melfrequency input. Parameter | def mel_to_hertz(self, mel):
# return 700.0 * (10**(mel / 2595.0)) - 700.0
return 250.0 * (9**(mel / 3340.0)) - 250.0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mils_to_freq(m):\n f = root_pitch['freq']*(2**(float(m)/12000))\n return f;",
"def get_frequency(self):\r\n x = self.query('FREQ?')\r\n if x == None: return None\r\n return float(x)",
"def get_frequency(self):\r\n return self.f",
"def get_frequency(self,):\n\n # T... | [
"0.75639445",
"0.7534624",
"0.7385637",
"0.73301536",
"0.73017204",
"0.7286359",
"0.72039306",
"0.7162466",
"0.70660377",
"0.7038995",
"0.699193",
"0.6963527",
"0.6956162",
"0.69514066",
"0.6950115",
"0.69422483",
"0.69422483",
"0.693355",
"0.6926402",
"0.69149095",
"0.689017... | 0.0 | -1 |
Returns centerfrequencies and band edges for a mel filter bank | def melfrequencies_mel_filterbank(self, num_bands, freq_min, freq_max, num_fft_bands):
mel_max = self.hertz_to_mel(freq_max)
mel_min = self.hertz_to_mel(freq_min)
delta_mel = abs(mel_max - mel_min) / (num_bands + 1.0)
frequencies_mel = mel_min + delta_mel * arange(0, num_bands + 2)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_filterbanks(nfilt=26,nfft=512,samplerate=16000,lowfreq=0,highfreq=None):\n highfreq= highfreq or samplerate/2\n assert highfreq <= samplerate/2, \"highfreq is greater than samplerate/2\"\n\n # compute points evenly spaced in mels\n lowmel = hz2mel(lowfreq)\n highmel = hz2mel(highfreq)\n\n ... | [
"0.62791246",
"0.62104696",
"0.6200014",
"0.61953336",
"0.6114515",
"0.6007833",
"0.5868187",
"0.58487403",
"0.5750124",
"0.57495075",
"0.5738013",
"0.5718509",
"0.56999505",
"0.5677948",
"0.56582195",
"0.5656211",
"0.55078876",
"0.54467714",
"0.5432982",
"0.53907806",
"0.539... | 0.698832 | 0 |
Returns tranformation matrix for mel spectrum. | def compute_melmat(self, num_mel_bands=12, freq_min=64, freq_max=8000,
num_fft_bands=513, sample_rate=16000):
center_frequencies_mel, lower_edges_mel, upper_edges_mel = self.melfrequencies_mel_filterbank(
num_mel_bands,
freq_min,
freq_max,
n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def galactic_to_MS():\n return MS_MATRIX",
"def get_mmt():\r\n # M^T\r\n MT = np.array([[-1, 0, 0, 0, 0, 0, 0, 0, 0],\r\n [1, -1, 0, 0, 0, 0, 0, 0, 0],\r\n [0, 1, -1, 0, 0, 0, 0, 0, 0],\r\n [0, 0, 1, -1, 0, 0, 0, 0, 0],\r\n [0, 0, 0... | [
"0.6515063",
"0.6490616",
"0.62550807",
"0.6227506",
"0.61941767",
"0.6173798",
"0.6162595",
"0.60898507",
"0.6087107",
"0.6067081",
"0.6044572",
"0.60382694",
"0.60369337",
"0.5993462",
"0.5985377",
"0.59686816",
"0.59636563",
"0.59495574",
"0.59419054",
"0.59140086",
"0.590... | 0.5764735 | 35 |
This function renames columns of a pandas dataframe It converts column names to snake case if rename_dict is not passed. | def cleanup_column_names(df, rename_dict={}, do_inplace=True):
if not rename_dict:
return df.rename(columns={col: col.lower().replace(' ', '_')
for col in df.columns.values.tolist()},
inplace=do_inplace)
else:
return df.rename(columns=re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def col_rename(col_dict, df_con_rename):\n\n for ex, nex in col_dict.items():\n df_con_rename = df_con_rename.withColumnRenamed(ex, nex)\n return df_con_rename",
"def lowercase_all_column_names(df:DataFrame)->DataFrame:\n for col in df.columns:\n df = df.withColumnRenamed(col, col.lower())... | [
"0.73472214",
"0.71769214",
"0.712079",
"0.7030749",
"0.6953978",
"0.6815323",
"0.6753903",
"0.6625544",
"0.6609549",
"0.6517022",
"0.6508362",
"0.64940655",
"0.6339",
"0.62789905",
"0.6255128",
"0.6241007",
"0.6222985",
"0.6205978",
"0.6147987",
"0.61346877",
"0.6118897",
... | 0.82928956 | 0 |
This function should be overriden in the derived classes and return moreorless successfull guess about calling convention | def guess_calling_convention(self):
return calldef_types.CALLING_CONVENTION_TYPES.UNKNOWN | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def guess_caller(vr):\n if \"source\" in vr.metadata and len(vr.metadata[\"source\"]) == 1:\n # Callers that follow the VCF spec: FreeBayes, pindel\n caller = vr.metadata[\"source\"][0].split(None, 1)[0]\n elif \"GATKCommandLine.MuTect\" in vr.metadata:\n # GATK/SATK 3.4+\n caller... | [
"0.6016491",
"0.5614761",
"0.5589595",
"0.53914446",
"0.5228716",
"0.52274674",
"0.5044258",
"0.50382453",
"0.5025339",
"0.50055414",
"0.50054145",
"0.49566883",
"0.49546763",
"0.49457833",
"0.49422875",
"0.49309742",
"0.49309742",
"0.49309742",
"0.49309742",
"0.49309742",
"0... | 0.7013889 | 0 |
list of class/class declaration types, extracted from the operator arguments | def class_types(self):
if None is self.__class_types:
self.__class_types = []
for type_ in self.argument_types:
decl = None
type_ = type_traits.remove_reference(type_)
if type_traits_classes.is_class(type_):
decl = type... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_types(*args, **kwargs) -> list:\n arg_types = []\n for arg in args:\n arg_types.append(type(arg))\n for values in kwargs.values():\n arg_types.append(type(values))\n return arg_types",
"def signature(cls) -> List[Term]:\n el = []\n for term ... | [
"0.6474247",
"0.6150577",
"0.61504894",
"0.61134005",
"0.60474235",
"0.604117",
"0.6033915",
"0.59675",
"0.5876862",
"0.5862628",
"0.581305",
"0.5805958",
"0.58015627",
"0.57808363",
"0.5776354",
"0.5773225",
"0.5770651",
"0.577052",
"0.57593215",
"0.5735517",
"0.5732222",
... | 0.69868934 | 0 |
Parses a list of events coming from the Slack RTM API to find bot commands. If a bot command is found, this function returns a tuple of command and metadata. If its not found, then this function returns None, None. | def parse_slack_events(slack_events):
for event in slack_events:
# Filter out certain event types from processing
if not event["type"] in FILTERED_OUT_TYPES:
debug_print(event)
else:
return None, None
if "thread_ts" in event:
ts = event["thread_ts... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_bot_commands(self, slack_events):\n for event in slack_events:\n if event[\"type\"] == \"message\" and not \"subtype\" in event:\n user_mention_id = event[\"user\"]\n user_id, message = self.parse_direct_mention(event[\"text\"])\n if user_id ... | [
"0.8044932",
"0.7913969",
"0.7892265",
"0.78835857",
"0.78828436",
"0.78828436",
"0.78828436",
"0.7862449",
"0.78439045",
"0.78184825",
"0.78069913",
"0.77614725",
"0.7707438",
"0.76585907",
"0.7584151",
"0.73585355",
"0.6172453",
"0.5843227",
"0.5842778",
"0.56936514",
"0.55... | 0.6041835 | 17 |
Finds a direct mention (a mention that is at the beginning) in message text and returns the user ID which was mentioned. If there is no direct mention, returns None | def parse_direct_mention(message_text):
matches = re.search(MENTION_REGEX, message_text)
# the first group contains the username, the second group contains the remaining message
return (matches.group(1), matches.group(2).strip()) if matches else (None, message_text.strip()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_direct_mention(message_text):\n # print(message_text)\n matches = re.search(MENTION_REGEX, message_text)\n # the first group contains the username, the second group contains the remaining message\n return (matches.group(1), matches.group(2).strip()) if matches else (None, None)",
"def parse... | [
"0.7675584",
"0.75857246",
"0.75798297",
"0.7578862",
"0.7578862",
"0.7578862",
"0.7578862",
"0.7578862",
"0.75755507",
"0.7573656",
"0.7557076",
"0.75313705",
"0.7441656",
"0.7441656",
"0.74106026",
"0.7318277",
"0.6749996",
"0.6414793",
"0.6312242",
"0.6284745",
"0.61999404... | 0.7393453 | 15 |
Executes bot command if the command is known | def handle_command(command, metadata):
# Default response is help text for the user
default_response = "Not sure what you mean, <@{}>. Try *{}*.".format(metadata["user"], HELP_COMMAND)
# Finds and executes the given command, filling in response
response = None
# Check command for FAQ keywords
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def command(self,ctx):\n await ctx.send(\"Yes this is a command.\")",
"def execute_command(command):\r\n if 0 == len(command):\r\n return\r\n\r\n if command[0] in verbs[\"move\"]:\r\n if len(command) <= 1:\r\n wrap_print(\"go where?\")\r\n else:\r\n e... | [
"0.6752725",
"0.6617937",
"0.6585033",
"0.6455056",
"0.6425135",
"0.63927513",
"0.6379973",
"0.63771737",
"0.6358033",
"0.6303008",
"0.6302788",
"0.62746096",
"0.6264084",
"0.6260362",
"0.62486637",
"0.6201165",
"0.61963415",
"0.61851525",
"0.610484",
"0.6103936",
"0.60957456... | 0.5844225 | 69 |
Tries to determine whether or not a user's message was a question | def is_question(text):
debug_print("Checking whether or not a question may have been asked.")
matches = re.search(QUESTION_REGEX, text)
debug_print(matches)
return True if matches else False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_question(self, message):\n text = message.split(' ')\n\n # get first word of message\n first_word = text[0]\n # get punctuation\n last_word = text[-1][-1]\n\n if first_word in self.question_words or last_word == '?':\n return True\n\n return False"... | [
"0.73923194",
"0.71005785",
"0.6917321",
"0.6764823",
"0.67535037",
"0.66870314",
"0.65741295",
"0.64395905",
"0.63611084",
"0.6324428",
"0.63240397",
"0.63166153",
"0.6299855",
"0.6289322",
"0.6237072",
"0.62319136",
"0.62239546",
"0.6112465",
"0.60908455",
"0.607894",
"0.60... | 0.6410361 | 8 |
Iterate through the condensed FAQ entries to expand all of the keywords and answers | def parse_faq_entries(entries):
parsed_entries = {}
for entry in entries:
for keyword in entry["keywords"]:
if keyword not in parsed_entries:
parsed_entries[keyword] = entry["answer"]
else:
print("Error: Found duplicate keyword '{}' in pre-configur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(data_item, article_id):\n questions = []\n answers = []\n paragraph = [article_id, data_item['context']]\n\n for item in data_item['qas']:\n question = [item[\"id\"], item[\"question\"], item['is_impossible']]\n questions.append(question)\n if item['is_impossible']:\n ... | [
"0.6092856",
"0.604264",
"0.5708487",
"0.57038796",
"0.5662298",
"0.5381249",
"0.5374494",
"0.53232485",
"0.5256146",
"0.52354884",
"0.52330977",
"0.52246875",
"0.5207684",
"0.5201199",
"0.51908934",
"0.5187937",
"0.5181439",
"0.5181076",
"0.51760966",
"0.5160842",
"0.5153228... | 0.67152536 | 0 |
Loads the FAQ from disk into memory | def read_faq_from_disk():
return json.load(open("./faq.json")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_knowledge(self):\n MemoryManager.load_memory(self.knowledge_file)",
"def load_corpus_questions():\r\n\tglobal search_criteria_dict, solution_dict, linked_abstracts_dict\r\n\tif os.path.exists(paths.path_data_questions_pickle):\r\n\t\tprint('\\nloading questions and answers')\r\n\t\tsearch_criteri... | [
"0.6981235",
"0.62057495",
"0.61173797",
"0.59236383",
"0.5770463",
"0.57657015",
"0.5753063",
"0.5708415",
"0.56874204",
"0.5681949",
"0.56623375",
"0.5654585",
"0.5630125",
"0.56003106",
"0.55774397",
"0.55369693",
"0.5526067",
"0.5508884",
"0.5482488",
"0.5453618",
"0.5451... | 0.72727674 | 0 |
Track all active conversations to pay attention to, and the users involved | def add_conversation(timestamp, user):
if timestamp not in ACTIVE_CONVS:
debug_print("Adding a new conversation.")
ACTIVE_CONVS[timestamp] = [user]
elif user not in ACTIVE_CONVS[timestamp]:
debug_print("Adding a new user to an active conversation.")
ACTIVE_CONVS[timestamp].append... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_conversations(self):\n\t\treturn self.conversations",
"def _track_changes(self):\n if self.untrack is False:\n self._event._track_changes.add('attendees')",
"def _track_changes(self):\n if self._untrack is False:\n self._event._track_changes.add('attendees')",
"def... | [
"0.6539912",
"0.615764",
"0.6152658",
"0.6038521",
"0.56193143",
"0.5527705",
"0.5492615",
"0.54740167",
"0.5429275",
"0.53827566",
"0.5335242",
"0.53251374",
"0.52755463",
"0.523182",
"0.51911193",
"0.5188668",
"0.5188668",
"0.51720464",
"0.5113954",
"0.5103253",
"0.5097042"... | 0.5973918 | 4 |
Checks whether or not a message that was sent belongs to an active conversation that the bot is in | def is_active_conv(timestamp):
debug_print("Checking to see if {} is an active conversation.".format(timestamp))
debug_print(ACTIVE_CONVS)
return timestamp in ACTIVE_CONVS | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter(self, message):\n conversations = Conversations()\n return conversations.get_conversation(message.from_user.id) is not None",
"def filter(self, message):\n conversations = Conversations()\n conversation = conversations.get_conversation(message.from_user.id)\n if conv... | [
"0.68307483",
"0.6709261",
"0.62747544",
"0.609343",
"0.59765625",
"0.59107685",
"0.58387476",
"0.57660055",
"0.5739228",
"0.57104665",
"0.56541896",
"0.5643942",
"0.56159776",
"0.5584048",
"0.55786204",
"0.55633813",
"0.55561924",
"0.5555065",
"0.55538917",
"0.55532825",
"0.... | 0.7009033 | 0 |
PrettyPrint to stdout if in debug mode | def debug_print(debug_data):
if DEBUG_MODE == "true":
pp.pprint(debug_data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def debug_print(text):\r\n if settings.debug:\r\n print (text)",
"def debug():",
"def debugPrint(text: str):\r\n if DEBUG:\r\n print(text)",
"def debugprint(debugobject, debugstring):\n if CMDLINEARGS.debug:\n print \"===== \" + debugstring + \" =====\"\n pprint.pprint(de... | [
"0.72024435",
"0.7062981",
"0.6972337",
"0.6967862",
"0.6967862",
"0.6959475",
"0.6913338",
"0.6794894",
"0.6765527",
"0.67562",
"0.67441654",
"0.6719388",
"0.6710147",
"0.6696881",
"0.6689538",
"0.66720015",
"0.6669009",
"0.6667993",
"0.6667386",
"0.6667287",
"0.66486543",
... | 0.7648205 | 0 |
Convert this cell to a GDSII structure. | def to_gds(self, outfile, multiplier, timestamp=None):
now = datetime.datetime.today() if timestamp is None else timestamp
name = self.name
if len(name) % 2 != 0:
name = name + "\0"
outfile.write(
struct.pack(
">2H12h2H",
28,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_gds(self, multiplier):\n name = self.ref_cell.name\n if len(name) % 2 != 0:\n name = name + '\\0'\n data = struct.pack('>4h', 4, 0x0B00, 4 + len(name),\n 0x1206) + name.encode('ascii')\n x2 = self.origin[0] + self.columns * self.spacing[0]\n ... | [
"0.5743448",
"0.55482465",
"0.5329714",
"0.53122056",
"0.5224355",
"0.51896095",
"0.51736516",
"0.5092857",
"0.5088674",
"0.5064377",
"0.50071204",
"0.500253",
"0.50019735",
"0.49925599",
"0.49596334",
"0.49314463",
"0.4929408",
"0.49142188",
"0.49131197",
"0.4898506",
"0.484... | 0.0 | -1 |
Create a copy of this cell. | def copy(
self,
name,
deep_copy=False,
translation=None,
rotation=None,
scale=None,
x_reflection=False,
):
new_cell = Cell(name)
transform = False
if (
x_reflection
or scale is not None
or rotation i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self) -> 'Cell':\n new = Cell(self.letter)\n new.player = self.player\n return new",
"def copy( self ):\n New = grid(self.data, self.xllcorner, self.yllcorner, self.cellsize, 'copy-'+self.name, self.nodata)\n return New",
"def clone(self):\n return self.__clas... | [
"0.80293596",
"0.7913326",
"0.723684",
"0.71645653",
"0.7103887",
"0.7075638",
"0.70546645",
"0.7012738",
"0.69686186",
"0.6943324",
"0.6937548",
"0.69350106",
"0.691416",
"0.69072473",
"0.6888141",
"0.68730575",
"0.68714637",
"0.6865083",
"0.68622196",
"0.67918915",
"0.67897... | 0.0 | -1 |
Add a new element or list of elements to this cell. | def add(self, element):
if isinstance(element, PolygonSet):
self.polygons.append(element)
elif isinstance(element, RobustPath) or isinstance(element, FlexPath):
self.paths.append(element)
elif isinstance(element, Label):
self.labels.append(element)
eli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, element):\n pass",
"def __add__(self, element):\r\n self.elements += element",
"def add(self, element):\n self.elements.append(element)",
"def add(self, elem):",
"def add(self, elem):",
"def add(self, value):\n if self._element_type is None:\n self._el... | [
"0.74574184",
"0.72338164",
"0.7212446",
"0.7192821",
"0.7192821",
"0.7062606",
"0.70556116",
"0.7030372",
"0.7027625",
"0.69985175",
"0.6966767",
"0.69208795",
"0.69156504",
"0.68597394",
"0.68459696",
"0.68118167",
"0.6810868",
"0.6800404",
"0.6760612",
"0.6732799",
"0.6712... | 0.72297215 | 2 |
Remove polygons from this cell. The function or callable `test` is called for each polygon in the cell. If its return value evaluates to True, the corresponding polygon is removed from the cell. | def remove_polygons(self, test):
filtered_polys = []
for element in self.polygons:
pld = [(poly, l, dt) for poly, l, dt in zip(element.polygons, element.layers, element.datatypes)
if not test(poly, l, dt)]
if len(pld) == 0:
pass # we don't need... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_polygons(self, test):\n empty = []\n for element in self.elements:\n if isinstance(element, PolygonSet):\n ii = 0\n while ii < len(element.polygons):\n if test(element.polygons[ii], element.layers[ii],\n ... | [
"0.80205756",
"0.6350466",
"0.6192517",
"0.61731756",
"0.60202783",
"0.600424",
"0.587869",
"0.5788355",
"0.5787628",
"0.560524",
"0.549923",
"0.5498585",
"0.54652745",
"0.54613364",
"0.5453875",
"0.5414428",
"0.5398999",
"0.5386263",
"0.535309",
"0.5336463",
"0.53328997",
... | 0.7925255 | 1 |
Remove paths from this cell. The function or callable `test` is called for each `FlexPath` or `RobustPath` in the cell. If its return value evaluates to True, the corresponding label is removed from the cell. | def remove_paths(self, test):
ii = 0
while ii < len(self.paths):
if test(self.paths[ii]):
self.paths.pop(ii)
else:
ii += 1
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_labels(self, test):\n ii = 0\n while ii < len(self.labels):\n if test(self.labels[ii]):\n self.labels.pop(ii)\n else:\n ii += 1\n return self",
"def remove_labels(self, test):\n ii = 0\n while ii < len(self.labels):... | [
"0.6118493",
"0.6118493",
"0.5951783",
"0.591622",
"0.57983315",
"0.5620718",
"0.5586181",
"0.55428076",
"0.5444423",
"0.5415851",
"0.53787106",
"0.534371",
"0.5319035",
"0.53083396",
"0.52550906",
"0.5251843",
"0.5233213",
"0.5228396",
"0.51878136",
"0.5161153",
"0.5153678",... | 0.7509545 | 0 |
Remove labels from this cell. The function or callable `test` is called for each label in the cell. If its return value evaluates to True, the corresponding label is removed from the cell. | def remove_labels(self, test):
ii = 0
while ii < len(self.labels):
if test(self.labels[ii]):
self.labels.pop(ii)
else:
ii += 1
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RemoveLabel(self, label):\n if self.labels is None:\n self.labels = set()\n else:\n try:\n self.labels.remove(label)\n except KeyError:\n pass",
"def remove_label(self, ):\n if self.AttributeNames.LABEL in self.attrs:\n ... | [
"0.65408283",
"0.6485277",
"0.63599694",
"0.6339318",
"0.6332027",
"0.6300747",
"0.6225751",
"0.6205483",
"0.6164012",
"0.6159746",
"0.6075823",
"0.6052966",
"0.59618044",
"0.58318126",
"0.58288985",
"0.58265567",
"0.5751653",
"0.5742358",
"0.56979746",
"0.5692929",
"0.565627... | 0.8710152 | 1 |
Calculate the total area of the elements on this cell, including cell references and arrays. | def area(self, by_spec=False):
if by_spec:
cell_area = {}
for element in itertools.chain(self.polygons, self.paths, self.references):
element_area = element.area(True)
for ll in element_area.keys():
if ll in cell_area:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getArea(self):\r\n return np.sum(self.array[:])",
"def total_area(self):\n return numpy.prod([r[1] - r[0] for r in self.range_])",
"def area(self, by_spec=False):\n if by_spec:\n cell_area = {}\n for element in self.elements:\n element_area = elemen... | [
"0.77725315",
"0.7599504",
"0.75269383",
"0.7497039",
"0.74537677",
"0.74429333",
"0.7378315",
"0.72832215",
"0.72520405",
"0.72520405",
"0.72520405",
"0.72520405",
"0.7251096",
"0.72318023",
"0.72269714",
"0.72177047",
"0.72038364",
"0.7172168",
"0.7172168",
"0.7172168",
"0.... | 0.71954083 | 17 |
Return the set of layers in this cell. Returns | def get_layers(self):
layers = set()
for element in itertools.chain(self.polygons, self.paths):
layers.update(element.layers)
for reference in self.references:
layers.update(reference.ref_cell.get_layers())
for label in self.labels:
layers.add(label.la... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def layers(self):\n return self['layers']",
"def layers(self):\r\n return self._flc.layers",
"def getLayers(self):\n return self.__layers",
"def get_layers(self):\n layers = set()\n for element in self.elements:\n if isinstance(element, PolygonSet):\n ... | [
"0.84161794",
"0.82297456",
"0.81984156",
"0.8153201",
"0.7760602",
"0.76984745",
"0.7670736",
"0.72703713",
"0.72165895",
"0.70526385",
"0.7021822",
"0.6928826",
"0.6922886",
"0.6842713",
"0.6831845",
"0.6688635",
"0.66676366",
"0.6658537",
"0.653411",
"0.64305663",
"0.63962... | 0.80953765 | 4 |
Return the set of datatypes in this cell. Returns | def get_datatypes(self):
datatypes = set()
for element in itertools.chain(self.polygons, self.paths):
datatypes.update(element.datatypes)
for reference in self.references:
datatypes.update(reference.ref_cell.get_datatypes())
return datatypes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_datatypes(self):\n datatypes = set()\n for element in self.elements:\n if isinstance(element, PolygonSet):\n datatypes.update(element.datatypes)\n elif isinstance(element, CellReference) or isinstance(\n element, CellArray):\n ... | [
"0.79858327",
"0.7341515",
"0.7284648",
"0.7140661",
"0.70937794",
"0.70203876",
"0.6859303",
"0.6851648",
"0.6838585",
"0.67846173",
"0.6766891",
"0.67228407",
"0.6693372",
"0.6677914",
"0.66178626",
"0.6582833",
"0.6564898",
"0.65541935",
"0.6541892",
"0.6519175",
"0.648535... | 0.7746643 | 1 |
Return the set of texttypes in this cell. Returns | def get_texttypes(self):
texttypes = set()
for reference in self.references:
texttypes.update(reference.ref_cell.get_textypes())
for label in self.labels:
texttypes.add(label.texttype)
return texttypes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetCellTypes(self):\n if not self.VTKObject.GetCellTypesArray():\n return None\n return vtkDataArrayToVTKArray(\n self.VTKObject.GetCellTypesArray(), self)",
"def types(self) -> List[str]:\n return self._types",
"def get_text_data_list(self):\n return [self... | [
"0.6864288",
"0.67568284",
"0.67244345",
"0.6621044",
"0.66001546",
"0.6592116",
"0.65660393",
"0.6514978",
"0.6501299",
"0.6420463",
"0.63704634",
"0.62760276",
"0.62488717",
"0.62406945",
"0.62165576",
"0.6175571",
"0.6156153",
"0.61535233",
"0.6119918",
"0.6073806",
"0.606... | 0.852494 | 0 |
Return the set of classes for the SVG representation of this cell. Returns | def get_svg_classes(self):
ld = set()
lt = set()
for element in itertools.chain(self.polygons, self.paths):
ld.update(zip(element.layers, element.datatypes))
for label in self.labels:
lt.add((label.layer, label.texttype))
for reference in self.references:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def classes(self):\n return self.browser.classes(self)",
"def classes(self):\n return self._.d",
"def getClasses(self):\n self._process()\n return self._sets",
"def classes(self):\r\n return self._classes",
"def get_classes(self):\n return self._classes",
"def cl... | [
"0.6673467",
"0.64993554",
"0.6337325",
"0.632925",
"0.6292911",
"0.6184021",
"0.6183241",
"0.6177004",
"0.6168098",
"0.6159375",
"0.6154537",
"0.6150669",
"0.6049886",
"0.60440177",
"0.6030368",
"0.59519166",
"0.5938959",
"0.5927353",
"0.5877505",
"0.58711433",
"0.586793",
... | 0.7874248 | 0 |
Calculate the bounding box for this cell. Returns | def get_bounding_box(self):
deps_still_valid = all(ref._bb_valid for ref in self.get_dependencies(True))
cached_bbox_still_valid = self._bb_valid and deps_still_valid
if not cached_bbox_still_valid:
bb = numpy.array(((1e300, 1e300), (-1e300, -1e300)))
all_polygons = []
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def boundingBox(self):\n minx, miny, maxx, maxy = self.substrates.bounds\n return pcbnew.BOX2I(\n pcbnew.VECTOR2I(int(minx), int(miny)),\n pcbnew.VECTOR2I(int(maxx - minx), int(maxy - miny)))",
"def bounding_box(self):\n if self.bbox is None:\n self.bbox = bo... | [
"0.8207344",
"0.81806314",
"0.81806314",
"0.81616205",
"0.81508523",
"0.79829717",
"0.7957958",
"0.7862182",
"0.78247416",
"0.7819618",
"0.7802205",
"0.779639",
"0.77903897",
"0.77657527",
"0.77332604",
"0.77099425",
"0.7704747",
"0.7704747",
"0.769051",
"0.7675328",
"0.76556... | 0.7544387 | 28 |
Return a list of polygons in this cell. | def get_polygons(self, by_spec=False, depth=None):
if depth is not None and depth < 0:
if not (by_spec is False or by_spec is True):
return []
bb = self.get_bounding_box()
if bb is None:
return {} if by_spec else []
pts = [
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polygons(self):\n if self.type == 'Polygon':\n polygons = [self._geojson['geometry']['coordinates']]\n elif self.type == 'MultiPolygon':\n polygons = self._geojson['geometry']['coordinates']\n return [ [ [_lat_lons_from_geojson(s) for\n s in... | [
"0.7842987",
"0.76190424",
"0.73368305",
"0.7279502",
"0.6892845",
"0.6884992",
"0.6835661",
"0.68140286",
"0.68037516",
"0.67662233",
"0.67419845",
"0.6739774",
"0.6721229",
"0.6649941",
"0.66383916",
"0.6628559",
"0.6622653",
"0.65800583",
"0.6566426",
"0.65041685",
"0.6502... | 0.64592654 | 22 |
Return a list with a copy of the polygons in this cell. | def get_polygonsets(self, depth=None):
polys = libcopy.deepcopy(self.polygons)
if depth is None or depth > 0:
for reference in self.references:
if depth is None:
next_depth = None
else:
next_depth = depth - 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polygons(self):\n if self.type == 'Polygon':\n polygons = [self._geojson['geometry']['coordinates']]\n elif self.type == 'MultiPolygon':\n polygons = self._geojson['geometry']['coordinates']\n return [ [ [_lat_lons_from_geojson(s) for\n s in... | [
"0.7547947",
"0.7316596",
"0.73041594",
"0.72470206",
"0.71213",
"0.69343984",
"0.69169277",
"0.6749382",
"0.6697183",
"0.6661932",
"0.6661799",
"0.6660124",
"0.66348714",
"0.6583003",
"0.6507498",
"0.6500448",
"0.6467257",
"0.63483876",
"0.6324975",
"0.63218826",
"0.6321436"... | 0.6666862 | 9 |
Return a list with a copy of the paths in this cell. | def get_paths(self, depth=None):
paths = libcopy.deepcopy(self.paths)
if depth is None or depth > 0:
for reference in self.references:
if depth is None:
next_depth = None
else:
next_depth = depth - 1
path... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def paths(self):\n rc = []\n for pg in self.path_groups:\n rc.extend(pg.paths)\n return rc",
"def get_paths(self, depth=None):\n if not isinstance(self.ref_cell, Cell):\n return []\n if self.origin is not None:\n trans = numpy.array(self.origin)... | [
"0.75346977",
"0.7523623",
"0.7383267",
"0.7332678",
"0.7327889",
"0.7327294",
"0.7296684",
"0.7296684",
"0.72939926",
"0.7270774",
"0.72187763",
"0.70349467",
"0.7021971",
"0.70194846",
"0.69415885",
"0.69395256",
"0.6937619",
"0.6858513",
"0.6819688",
"0.67919797",
"0.67910... | 0.64189625 | 35 |
Return a list with a copy of the labels in this cell. | def get_labels(self, depth=None, set_transform=False):
labels = libcopy.deepcopy(self.labels)
if depth is None or depth > 0:
for reference in self.references:
if depth is None:
next_depth = None
else:
next_depth = depth ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def labels(self) -> list:\n return self._labels",
"def get_labels(self):\n return []",
"def labels(self):\n return self._labels",
"def get_labels(self) -> List[str]:\n return self.labels",
"def list_of_labels(self):\n L = np.unique(self.box_label)\n return np.union1d(L... | [
"0.7925544",
"0.789087",
"0.77288866",
"0.77160776",
"0.7671561",
"0.762041",
"0.7586169",
"0.7586169",
"0.7586169",
"0.7586169",
"0.7586169",
"0.7586169",
"0.7457129",
"0.7432928",
"0.7426808",
"0.73899865",
"0.7378445",
"0.73713386",
"0.7368412",
"0.72897375",
"0.7285032",
... | 0.0 | -1 |
Return a set of the cells included in this cell as references. | def get_dependencies(self, recursive=False):
dependencies = set()
for reference in self.references:
if isinstance(reference.ref_cell, Cell):
if recursive:
dependencies.update(reference.ref_cell.get_dependencies(True))
dependencies.add(refer... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def references(self) -> \"IterableList[Reference]\":\n return Reference.list_items(self)",
"def get_references(self):\n\n return self._refs",
"def get_references(self):\n return self._references",
"def referencing_nodes(self):\n\n return self._referencing_nodes",
"def refere... | [
"0.6819724",
"0.6730786",
"0.6708101",
"0.66307276",
"0.65374833",
"0.64513767",
"0.64364344",
"0.6364836",
"0.6364836",
"0.6356147",
"0.6325696",
"0.6325696",
"0.62790745",
"0.62559783",
"0.62235403",
"0.62235177",
"0.6222344",
"0.6185836",
"0.6093392",
"0.602159",
"0.601182... | 0.6488647 | 5 |
Convert all references into polygons, paths and labels. | def flatten(self, single_layer=None, single_datatype=None, single_texttype=None):
self.labels = self.get_labels()
if single_layer is not None and single_datatype is not None:
for lbl in self.labels:
lbl.layer = single_layer
lbl.texttype = single_texttype
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _process_references0(self, references):\n if \"zarr_consolidated_format\" in references:\n # special case for Ike prototype\n references = _unmodel_hdf5(references)\n self.references = references",
"def generatePolygons():",
"def _export_reference_representations(self):\... | [
"0.5647293",
"0.5646024",
"0.5635338",
"0.5630123",
"0.55962205",
"0.5404384",
"0.54007363",
"0.53235346",
"0.526006",
"0.5224974",
"0.5224784",
"0.5187493",
"0.5183223",
"0.51739013",
"0.51446986",
"0.5121586",
"0.5110074",
"0.5085551",
"0.5060123",
"0.50405365",
"0.5003779"... | 0.52513164 | 9 |
Write an SVG fragment representation of this object. | def to_svg(self, outfile, scaling, precision, attributes):
outfile.write('<g id="')
outfile.write(self.name.replace("#", "_"))
outfile.write('" ')
outfile.write(attributes)
outfile.write(">\n")
for polygon in self.polygons:
polygon.to_svg(outfile, scaling, pre... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_svg(\n self,\n outfile,\n scaling=10,\n style=None,\n fontstyle=None,\n background=\"#222\",\n pad=\"5%\",\n precision=None,\n ):\n bb = self.get_bounding_box()\n if bb is None:\n return\n close = True\n if ... | [
"0.64034855",
"0.62927806",
"0.6089161",
"0.6064701",
"0.60599434",
"0.60150325",
"0.58418894",
"0.58044386",
"0.5791056",
"0.570158",
"0.5671584",
"0.5624105",
"0.5615185",
"0.5587682",
"0.5575867",
"0.55718195",
"0.55718195",
"0.5566151",
"0.55476576",
"0.55405116",
"0.5510... | 0.678781 | 0 |
Export this cell to an SVG file. The dimensions actually written on the GDSII file will be the dimensions of the objects created times the ratio unit/precision. For example, if a circle with radius 1.5 is created and we set `GdsLibrary.unit` to 1.0e6 (1 um) and `GdsLibrary.precision` to 1.0e9` (1 nm), the radius of the... | def write_svg(
self,
outfile,
scaling=10,
style=None,
fontstyle=None,
background="#222",
pad="5%",
precision=None,
):
bb = self.get_bounding_box()
if bb is None:
return
close = True
if hasattr(outfile, "__fsp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_svg(self, outfile, scaling, precision, attributes):\n outfile.write('<g id=\"')\n outfile.write(self.name.replace(\"#\", \"_\"))\n outfile.write('\" ')\n outfile.write(attributes)\n outfile.write(\">\\n\")\n for polygon in self.polygons:\n polygon.to_svg(... | [
"0.7521533",
"0.7285852",
"0.71931106",
"0.6398051",
"0.6342033",
"0.631223",
"0.62910724",
"0.6230578",
"0.6223311",
"0.6193851",
"0.6173615",
"0.6173615",
"0.61700886",
"0.6163268",
"0.60564893",
"0.60334575",
"0.602575",
"0.60175425",
"0.6004667",
"0.59768134",
"0.59603375... | 0.68822676 | 3 |
Convert this object to a GDSII element. | def to_gds(self, outfile, multiplier):
if isinstance(self.ref_cell, Cell):
name = self.ref_cell.name
else:
name = self.ref_cell
if len(name) % 2 != 0:
name = name + "\0"
outfile.write(struct.pack(">4H", 4, 0x0A00, 4 + len(name), 0x1206))
outfil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toXML(self):\n return _libsbml.GraphicalObject_toXML(self)",
"def toGML(self):\n raise NotImplementedError",
"def __str__(self):\n return str(self.element)",
"def __repr__(self):\n return (\n f\"<Element: {self.name}, symbol: {self.symbol}, \"\n f\"atomic... | [
"0.5857224",
"0.5810739",
"0.543184",
"0.5416807",
"0.5341295",
"0.5325705",
"0.5284019",
"0.5283045",
"0.52636915",
"0.522651",
"0.522556",
"0.52075106",
"0.51756334",
"0.51669174",
"0.5161292",
"0.51580524",
"0.5128812",
"0.51284176",
"0.5080394",
"0.50741917",
"0.50666416"... | 0.0 | -1 |
Write an SVG fragment representation of this object. | def to_svg(self, outfile, scaling, precision):
if isinstance(self.ref_cell, Cell):
name = self.ref_cell.name
else:
name = self.ref_cell
transform = "translate({} {})".format(
numpy.format_float_positional(
scaling * self.origin[0], trim="0", pr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_svg(self, outfile, scaling, precision, attributes):\n outfile.write('<g id=\"')\n outfile.write(self.name.replace(\"#\", \"_\"))\n outfile.write('\" ')\n outfile.write(attributes)\n outfile.write(\">\\n\")\n for polygon in self.polygons:\n polygon.to_svg(... | [
"0.678781",
"0.64034855",
"0.6089161",
"0.6064701",
"0.60599434",
"0.60150325",
"0.58418894",
"0.58044386",
"0.5791056",
"0.570158",
"0.5671584",
"0.5624105",
"0.5615185",
"0.5587682",
"0.5575867",
"0.55718195",
"0.55718195",
"0.5566151",
"0.55476576",
"0.55405116",
"0.551035... | 0.62927806 | 2 |
Calculate the total area of the referenced cell with the magnification factor included. | def area(self, by_spec=False):
if not isinstance(self.ref_cell, Cell):
return dict() if by_spec else 0
if self.magnification is None:
return self.ref_cell.area(by_spec)
else:
if by_spec:
factor = self.magnification ** 2
cell_are... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def area(self, by_spec=False):\n if not isinstance(self.ref_cell, Cell):\n return dict() if by_spec else 0\n if self.magnification is None:\n factor = self.columns * self.rows\n else:\n factor = self.columns * self.rows * self.magnification**2\n if by_sp... | [
"0.7243287",
"0.7239991",
"0.7231403",
"0.70159674",
"0.6785667",
"0.6785667",
"0.6785667",
"0.6785667",
"0.6748671",
"0.67300946",
"0.6710924",
"0.6710924",
"0.6710924",
"0.66895485",
"0.66840756",
"0.6652378",
"0.66498977",
"0.6617837",
"0.66032726",
"0.6585019",
"0.6581661... | 0.72300845 | 3 |
Transform a set of polygons. This reference transformation is used to transform the given polygons in place. | def _transform_polygons(self, polygons):
if self.rotation is not None:
ct = numpy.cos(self.rotation * numpy.pi / 180.0)
st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone
if self.x_reflection:
xrefl = numpy.array((1, -1))
if self.magnification is not No... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _transform_polygons(self, polygons):\n if self.rotation is not None:\n ct = numpy.cos(self.rotation * numpy.pi / 180.0)\n st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone\n if self.magnification is not None:\n mag = numpy.array((self.magnification, self.m... | [
"0.7867194",
"0.5765913",
"0.55117023",
"0.55035955",
"0.5446485",
"0.5436907",
"0.5436537",
"0.5431551",
"0.5428468",
"0.5427553",
"0.5419052",
"0.5384409",
"0.53389496",
"0.53316414",
"0.53243774",
"0.5288421",
"0.52567446",
"0.5184014",
"0.5177287",
"0.5158781",
"0.5148572... | 0.7864645 | 1 |
Return the list of polygons created by this reference. | def get_polygons(self, by_spec=False, depth=None):
if not isinstance(self.ref_cell, Cell):
return dict() if by_spec else []
polygons = self.ref_cell.get_polygons(by_spec, depth)
return self._transform_polygons(polygons) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polygons(self):\n if self.type == 'Polygon':\n polygons = [self._geojson['geometry']['coordinates']]\n elif self.type == 'MultiPolygon':\n polygons = self._geojson['geometry']['coordinates']\n return [ [ [_lat_lons_from_geojson(s) for\n s in... | [
"0.7791119",
"0.762329",
"0.74445224",
"0.71422297",
"0.7099408",
"0.70776516",
"0.7035478",
"0.68038243",
"0.67995584",
"0.67361677",
"0.66761684",
"0.66194516",
"0.6583179",
"0.6582501",
"0.6552869",
"0.6534296",
"0.6519639",
"0.6498464",
"0.6493398",
"0.64807975",
"0.64200... | 0.6444032 | 20 |
Return the list of polygons created by this reference. | def get_polygonsets(self, depth=None):
if not isinstance(self.ref_cell, Cell):
return []
if self.rotation is not None:
ct = numpy.cos(self.rotation * numpy.pi / 180.0)
st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone
if self.x_reflection:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polygons(self):\n if self.type == 'Polygon':\n polygons = [self._geojson['geometry']['coordinates']]\n elif self.type == 'MultiPolygon':\n polygons = self._geojson['geometry']['coordinates']\n return [ [ [_lat_lons_from_geojson(s) for\n s in... | [
"0.7792467",
"0.7624696",
"0.74459255",
"0.71419406",
"0.70993507",
"0.70769495",
"0.70361227",
"0.68006146",
"0.6737182",
"0.6677578",
"0.66189504",
"0.65839696",
"0.6583549",
"0.65531653",
"0.6534705",
"0.652067",
"0.6500624",
"0.6494521",
"0.6480914",
"0.64441115",
"0.6418... | 0.68033767 | 7 |
Return the list of paths created by this reference. | def get_paths(self, depth=None):
if not isinstance(self.ref_cell, Cell):
return []
if self.origin is not None:
trans = numpy.array(self.origin)
else:
trans = None
if self.rotation is not None:
rot = self.rotation * numpy.pi / 180.0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_paths(self):\n return self.paths",
"def paths(self):\r\n return self._paths",
"def GetPaths(self):\n return self.paths",
"def paths(self):\n return self._paths",
"def paths(self):\n return self._paths",
"def path(self) -> List[Path]:\n return self._path",... | [
"0.8311262",
"0.8302748",
"0.8254829",
"0.8254413",
"0.8254413",
"0.81395245",
"0.7954077",
"0.79534584",
"0.7673039",
"0.7611283",
"0.7585028",
"0.75215286",
"0.7484188",
"0.7440461",
"0.7438975",
"0.7435275",
"0.73708534",
"0.73636985",
"0.73252803",
"0.7296981",
"0.7265272... | 0.67454743 | 39 |
Return the list of labels created by this reference. | def get_labels(self, depth=None, set_transform=False):
if not isinstance(self.ref_cell, Cell):
return []
if self.rotation is not None:
ct = numpy.cos(self.rotation * numpy.pi / 180.0)
st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone
if self.x_reflecti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def labels(self) -> list:\n return self._labels",
"def get_labels(self) -> List[str]:\n return self.labels",
"def get_labels(self):\n return []",
"def get_labels(self) -> List[str]:\n raise NotImplementedError()",
"def labels(self):\n return self._labels",
"def labels(self)... | [
"0.8515524",
"0.8482789",
"0.84210205",
"0.84087145",
"0.8233267",
"0.82061845",
"0.82061845",
"0.82061845",
"0.82061845",
"0.82061845",
"0.82061845",
"0.81545305",
"0.7964697",
"0.7921453",
"0.7915286",
"0.7915286",
"0.7915286",
"0.7915286",
"0.7915286",
"0.7915286",
"0.7915... | 0.0 | -1 |
Calculate the bounding box for this reference. Returns | def get_bounding_box(self):
if not isinstance(self.ref_cell, Cell):
return None
if self.rotation is None or self.rotation % 90 == 0:
cell_bbox = self.ref_cell.get_bounding_box()
if cell_bbox is None:
return None
polygons = self._transform_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bounding_box(self):\n deps_still_valid = all(ref._bb_valid for ref in self.get_dependencies(True))\n cached_bbox_still_valid = self._bb_valid and deps_still_valid\n if not cached_bbox_still_valid:\n bb = numpy.array(((1e300, 1e300), (-1e300, -1e300)))\n all_polygo... | [
"0.8494973",
"0.8335019",
"0.8335019",
"0.8331231",
"0.8283461",
"0.8235353",
"0.8215106",
"0.8186653",
"0.81768817",
"0.8176806",
"0.81503516",
"0.8050574",
"0.7977073",
"0.7914641",
"0.7886893",
"0.78447485",
"0.7824194",
"0.7816102",
"0.78095555",
"0.775125",
"0.7634715",
... | 0.8022996 | 12 |
Convert this object to a GDSII element. | def to_gds(self, outfile, multiplier):
if isinstance(self.ref_cell, Cell):
name = self.ref_cell.name
else:
name = self.ref_cell
if len(name) % 2 != 0:
name = name + "\0"
outfile.write(struct.pack(">4H", 4, 0x0B00, 4 + len(name), 0x1206))
outfil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toXML(self):\n return _libsbml.GraphicalObject_toXML(self)",
"def toGML(self):\n raise NotImplementedError",
"def __str__(self):\n return str(self.element)",
"def __repr__(self):\n return (\n f\"<Element: {self.name}, symbol: {self.symbol}, \"\n f\"atomic... | [
"0.58556783",
"0.58110946",
"0.5431924",
"0.5416439",
"0.5339593",
"0.5323014",
"0.52841514",
"0.5283188",
"0.5260789",
"0.5224168",
"0.5223884",
"0.5206834",
"0.51746875",
"0.5171212",
"0.51643103",
"0.5156278",
"0.5127905",
"0.5125808",
"0.5079717",
"0.507325",
"0.50696474"... | 0.0 | -1 |
Write an SVG fragment representation of this object. | def to_svg(self, outfile, scaling, precision):
if isinstance(self.ref_cell, Cell):
name = self.ref_cell.name
else:
name = self.ref_cell
transform = "translate({} {})".format(
numpy.format_float_positional(
scaling * self.origin[0], trim="0", pr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_svg(self, outfile, scaling, precision, attributes):\n outfile.write('<g id=\"')\n outfile.write(self.name.replace(\"#\", \"_\"))\n outfile.write('\" ')\n outfile.write(attributes)\n outfile.write(\">\\n\")\n for polygon in self.polygons:\n polygon.to_svg(... | [
"0.678781",
"0.64034855",
"0.62927806",
"0.6089161",
"0.6064701",
"0.60599434",
"0.58418894",
"0.58044386",
"0.5791056",
"0.570158",
"0.5671584",
"0.5624105",
"0.5615185",
"0.5587682",
"0.5575867",
"0.55718195",
"0.55718195",
"0.5566151",
"0.55476576",
"0.55405116",
"0.551035... | 0.60150325 | 6 |
Calculate the total area of the cell array with the magnification factor included. | def area(self, by_spec=False):
if not isinstance(self.ref_cell, Cell):
return dict() if by_spec else 0
if self.magnification is None:
factor = self.columns * self.rows
else:
factor = self.columns * self.rows * self.magnification ** 2
if by_spec:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculatearea(self):\r\n return self.width * self.height",
"def area(self, by_spec=False):\n if not isinstance(self.ref_cell, Cell):\n return dict() if by_spec else 0\n if self.magnification is None:\n factor = self.columns * self.rows\n else:\n fa... | [
"0.7014719",
"0.6929633",
"0.68529356",
"0.68506974",
"0.67594755",
"0.667792",
"0.663422",
"0.663422",
"0.663422",
"0.663422",
"0.65729547",
"0.6572029",
"0.6572029",
"0.6572029",
"0.65689194",
"0.656555",
"0.65610254",
"0.65354156",
"0.6515844",
"0.65145904",
"0.6505233",
... | 0.6924989 | 2 |
Transform a set of polygons. This reference transformation is used to transform the given polygons. | def _transform_polygons(self, polygons):
if self.rotation is not None:
ct = numpy.cos(self.rotation * numpy.pi / 180.0)
st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone
if self.magnification is not None:
mag = numpy.array((self.magnification, self.magnificati... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _transform_polygons(self, polygons):\n if self.rotation is not None:\n ct = numpy.cos(self.rotation * numpy.pi / 180.0)\n st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone\n if self.x_reflection:\n xrefl = numpy.array((1, -1))\n if self.magnificatio... | [
"0.785101",
"0.5796514",
"0.559841",
"0.55872154",
"0.55240583",
"0.5515661",
"0.55025566",
"0.5487049",
"0.5435642",
"0.54168725",
"0.54126465",
"0.53939325",
"0.53696126",
"0.5351234",
"0.5342615",
"0.5257946",
"0.5232036",
"0.521499",
"0.52135664",
"0.51902133",
"0.5137937... | 0.78590536 | 0 |
Return the list of polygons created by this reference. | def get_polygons(self, by_spec=False, depth=None):
if not isinstance(self.ref_cell, Cell):
return dict() if by_spec else []
cell_polygons = self.ref_cell.get_polygons(by_spec, depth)
return self._transform_polygons(cell_polygons) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polygons(self):\n if self.type == 'Polygon':\n polygons = [self._geojson['geometry']['coordinates']]\n elif self.type == 'MultiPolygon':\n polygons = self._geojson['geometry']['coordinates']\n return [ [ [_lat_lons_from_geojson(s) for\n s in... | [
"0.7792467",
"0.7624696",
"0.74459255",
"0.71419406",
"0.70993507",
"0.70769495",
"0.70361227",
"0.68033767",
"0.68006146",
"0.6737182",
"0.6677578",
"0.66189504",
"0.65839696",
"0.6583549",
"0.65531653",
"0.6534705",
"0.652067",
"0.6500624",
"0.6494521",
"0.6480914",
"0.6444... | 0.6368692 | 23 |
Return the list of polygons created by this reference. | def get_polygonsets(self, depth=None):
if not isinstance(self.ref_cell, Cell):
return []
if self.rotation is not None:
ct = numpy.cos(self.rotation * numpy.pi / 180.0)
st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone
if self.x_reflection:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polygons(self):\n if self.type == 'Polygon':\n polygons = [self._geojson['geometry']['coordinates']]\n elif self.type == 'MultiPolygon':\n polygons = self._geojson['geometry']['coordinates']\n return [ [ [_lat_lons_from_geojson(s) for\n s in... | [
"0.7791119",
"0.762329",
"0.74445224",
"0.71422297",
"0.7099408",
"0.70776516",
"0.7035478",
"0.68038243",
"0.67995584",
"0.67361677",
"0.66761684",
"0.6583179",
"0.6582501",
"0.6552869",
"0.6534296",
"0.6519639",
"0.6498464",
"0.6493398",
"0.64807975",
"0.6444032",
"0.642005... | 0.66194516 | 11 |
Return the list of paths created by this reference. | def get_paths(self, depth=None):
if not isinstance(self.ref_cell, Cell):
return []
if self.origin is not None:
trans = numpy.array(self.origin)
else:
trans = None
if self.rotation is not None:
rot = self.rotation * numpy.pi / 180.0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_paths(self):\n return self.paths",
"def paths(self):\r\n return self._paths",
"def GetPaths(self):\n return self.paths",
"def paths(self):\n return self._paths",
"def paths(self):\n return self._paths",
"def path(self) -> List[Path]:\n return self._path",... | [
"0.8309927",
"0.8301452",
"0.8253446",
"0.8253089",
"0.8253089",
"0.81387806",
"0.79529196",
"0.7952184",
"0.76709217",
"0.7609567",
"0.7583138",
"0.7520623",
"0.74843603",
"0.7439155",
"0.74380785",
"0.7434079",
"0.73696697",
"0.7361946",
"0.73235893",
"0.72955364",
"0.72640... | 0.65511405 | 48 |
Return the list of labels created by this reference. | def get_labels(self, depth=None, set_transform=False):
if not isinstance(self.ref_cell, Cell):
return []
if self.rotation is not None:
ct = numpy.cos(self.rotation * numpy.pi / 180.0)
st = numpy.sin(self.rotation * numpy.pi / 180.0) * _mpone
if self.magnificat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def labels(self) -> list:\n return self._labels",
"def get_labels(self) -> List[str]:\n return self.labels",
"def get_labels(self):\n return []",
"def get_labels(self) -> List[str]:\n raise NotImplementedError()",
"def labels(self):\n return self._labels",
"def labels(self)... | [
"0.8516112",
"0.84839594",
"0.8422236",
"0.84098774",
"0.8234229",
"0.8206628",
"0.8206628",
"0.8206628",
"0.8206628",
"0.8206628",
"0.8206628",
"0.8155338",
"0.7965425",
"0.7922409",
"0.79160345",
"0.79160345",
"0.79160345",
"0.79160345",
"0.79160345",
"0.79160345",
"0.79160... | 0.0 | -1 |
Calculate the bounding box for this reference. Returns | def get_bounding_box(self):
if not isinstance(self.ref_cell, Cell):
return None
if self.rotation is None or self.rotation % 90 == 0:
cell_bbox = self.ref_cell.get_bounding_box()
if cell_bbox is None:
return None
polygons = self._transform_p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bounding_box(self):\n deps_still_valid = all(ref._bb_valid for ref in self.get_dependencies(True))\n cached_bbox_still_valid = self._bb_valid and deps_still_valid\n if not cached_bbox_still_valid:\n bb = numpy.array(((1e300, 1e300), (-1e300, -1e300)))\n all_polygo... | [
"0.8496508",
"0.83368224",
"0.83368224",
"0.8332704",
"0.8283734",
"0.8235681",
"0.8217295",
"0.8187952",
"0.81789",
"0.81771076",
"0.8152201",
"0.8023084",
"0.7978836",
"0.7915937",
"0.7889683",
"0.7846862",
"0.7826866",
"0.7819128",
"0.78119254",
"0.77532214",
"0.7636975",
... | 0.8050689 | 11 |
Create a new cell and add it to this library. | def new_cell(self, name, overwrite_duplicate=False, update_references=True):
cell = Cell(name)
self.add(cell, False, overwrite_duplicate, update_references)
return cell | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_cell(self, cid):\n self.cells[cid] = Cell()",
"def createCell(self, xPos, yPos):\n self.cells.append(Cell(self.screen, xPos, yPos))",
"def _create_cell(self,row_number,cell_number):\n cell = Cell(self)\n cell.x = cell_number * self.cell_width\n cell.y = row_number ... | [
"0.7582513",
"0.740403",
"0.7224304",
"0.71756005",
"0.70146143",
"0.6870246",
"0.6796258",
"0.6674156",
"0.6638308",
"0.6601923",
"0.65517443",
"0.651863",
"0.649863",
"0.6458009",
"0.6449549",
"0.6430993",
"0.6413602",
"0.6393372",
"0.6347527",
"0.62470824",
"0.6243126",
... | 0.7377023 | 2 |
Add one or more cells to the library. | def add(
self,
cell,
include_dependencies=True,
overwrite_duplicate=False,
update_references=True,
):
if isinstance(cell, Cell):
cell_set = set([cell])
if include_dependencies:
cell_set.update(cell.get_dependencies(True))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_cell(self, cell: Cell):\n\n self.cells.append(cell)",
"def add_cells(self):\n # To delete all common cells\n self.delete_cells()\n if self.removed_last_bracket:\n new_lib = self.base_doc + self.cell_doc + '\\n}\\n'\n else:\n end_part = self.base_do... | [
"0.7153042",
"0.70961",
"0.69793475",
"0.6639552",
"0.65566367",
"0.64485896",
"0.64260375",
"0.6350621",
"0.63257134",
"0.61614436",
"0.59996146",
"0.59594357",
"0.5953101",
"0.5933116",
"0.5920777",
"0.59127015",
"0.58612245",
"0.58154446",
"0.5807713",
"0.578784",
"0.57434... | 0.6412283 | 7 |
Remove a cell from the library. | def remove(self, cell, remove_references=True):
if isinstance(cell, Cell):
name = cell.name
else:
name = cell
if name in self.cells:
del self.cells[name]
removed = 0
if remove_references:
for c in self.cells.values():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _remove(self, cell_coord, o):\n cell = self.d[cell_coord]\n cell.remove(o)\n\n # Delete the cell from the hash if it is empty.\n if not cell:\n del(self.d[cell_coord])",
"def remove_cell(self, cell: Cell):\r\n assert isinstance(cell, Cell)\r\n self.size -=... | [
"0.78183174",
"0.78140616",
"0.77669454",
"0.7218418",
"0.7174134",
"0.69584143",
"0.69113976",
"0.6767365",
"0.6658349",
"0.66415673",
"0.6636562",
"0.6631602",
"0.65876555",
"0.6454404",
"0.6416677",
"0.6401591",
"0.63443387",
"0.6342481",
"0.6337022",
"0.6308937",
"0.62808... | 0.6749035 | 8 |
Write the GDSII library to a file. The dimensions actually written on the GDSII file will be the dimensions of the objects created times the ratio unit/precision. For example, if a circle with radius 1.5 is created and we set `GdsLibrary.unit` to 1.0e6 (1 um) and `GdsLibrary.precision` to 1.0e9` (1 nm), the radius of t... | def write_gds(self, outfile, cells=None, timestamp=None, binary_cells=None):
close = True
if hasattr(outfile, "__fspath__"):
outfile = open(outfile.__fspath__(), "wb")
elif isinstance(outfile, (basestring, Path)):
outfile = open(outfile, "wb")
else:
cl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_gds(outfile,\n cells=None,\n name='library',\n unit=1.0e-6,\n precision=1.0e-9):\n current_library.name = name\n current_library.unit = unit\n current_library.precision = precision\n current_library.write_gds(outfile, cells)",
"def write(s... | [
"0.75257516",
"0.7131023",
"0.63836277",
"0.59522474",
"0.5937476",
"0.58502436",
"0.5809515",
"0.5798301",
"0.5789873",
"0.57749695",
"0.5767537",
"0.57370085",
"0.5711578",
"0.5699197",
"0.5641816",
"0.5641022",
"0.56182075",
"0.5606908",
"0.55280125",
"0.5525817",
"0.54929... | 0.6201605 | 3 |
Read a GDSII file into this library. | def read_gds(
self,
infile,
units="skip",
rename={},
rename_template="{name}",
layers={},
datatypes={},
texttypes={},
):
self._references = []
close = True
if hasattr(infile, "__fspath__"):
infile = open(infile.__fsp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_file(file):\n if opts.input_type == 'fits':\n data = fileio.read_fits(file)\n else:\n data = fileio.read_ascii(file)\n c_id = data[0,:]\n g_num = np.array(range(len(c_id)), dtype = 'int')\n g_id = data[3,:]\n g_ra = np.array(data[4,:], dtype = 'float')\n g_dec = np.array... | [
"0.6245018",
"0.616701",
"0.6092572",
"0.60005844",
"0.5868339",
"0.58612186",
"0.5825995",
"0.57988286",
"0.57988286",
"0.5784195",
"0.57717836",
"0.5764157",
"0.57621366",
"0.57600033",
"0.5706241",
"0.57049376",
"0.570334",
"0.56551987",
"0.565489",
"0.5630139",
"0.5619926... | 0.5549735 | 25 |
Output the top level cells from the GDSII data. Top level cells are those that are not referenced by any other cells. Returns | def top_level(self):
top = set(self)
for cell in self:
top.difference_update(cell.get_dependencies())
return list(top) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top_level(self):\n top = list(self.cell_dict.values())\n for cell in self.cell_dict.values():\n for dependency in cell.get_dependencies():\n if dependency in top:\n top.remove(dependency)\n return top",
"def draw_open_cells(self):\n emp... | [
"0.6141585",
"0.5927244",
"0.56945705",
"0.56243724",
"0.5589779",
"0.5477621",
"0.5411163",
"0.54090655",
"0.5380761",
"0.5363793",
"0.53398967",
"0.53345144",
"0.5295822",
"0.52840114",
"0.5265799",
"0.5230088",
"0.5228775",
"0.5225207",
"0.52107006",
"0.52086085",
"0.52085... | 0.5610892 | 4 |
Rename an existing cell in the library. | def rename_cell(self, cell, name, update_references=True):
if isinstance(cell, Cell):
old_name = cell.name
if old_name not in self.cells:
raise ValueError(
"[GDSPY] Cell named {0} not present in library.".format(old_name)
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def name(self, new_name):\n self.rename(new_name)",
"def cellModified(self):\n\n x = self.tableWidget_journals.currentRow()\n y = self.tableWidget_journals.currentColumn()\n if y == self.NAME_COLUMN:\n newName = str(self.tableWidget_journals.item(x, y).text()).strip().encod... | [
"0.58167297",
"0.57922983",
"0.5770913",
"0.5732452",
"0.5716103",
"0.5663834",
"0.56498533",
"0.56498533",
"0.56417304",
"0.5641613",
"0.56392765",
"0.558007",
"0.5527694",
"0.55087227",
"0.54747593",
"0.5461296",
"0.53917825",
"0.53753626",
"0.5354214",
"0.5341221",
"0.5337... | 0.8026026 | 0 |
Replace cells in all references in the library. All `CellReference` and `CellArray` using the `old_cell` are updated to reference `new_cell`. Matching with `old_cell` is by name only. | def replace_references(self, old_cell, new_cell):
if isinstance(old_cell, Cell):
old_name = old_cell.name
else:
old_name = old_cell
if not isinstance(new_cell, Cell) and new_cell in self.cells:
new_cell = self.cells[new_cell]
replacements = 0
f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rename_cell(self, cell, name, update_references=True):\n if isinstance(cell, Cell):\n old_name = cell.name\n if old_name not in self.cells:\n raise ValueError(\n \"[GDSPY] Cell named {0} not present in library.\".format(old_name)\n )... | [
"0.60519004",
"0.5878847",
"0.5818164",
"0.57240033",
"0.5468772",
"0.5437272",
"0.5320144",
"0.5285266",
"0.52246344",
"0.5099337",
"0.505342",
"0.5046812",
"0.50462395",
"0.5032131",
"0.4985268",
"0.49477512",
"0.49297217",
"0.48797628",
"0.4874498",
"0.48279476",
"0.482275... | 0.7644548 | 0 |
Extract a cell from the this GDSII file and include it in the current global library, including referenced dependencies. | def extract(self, cell, overwrite_duplicate=False):
warnings.warn(
"[GDSPY] extract and the use of the global library is deprecated.",
category=DeprecationWarning,
stacklevel=2,
)
import gdspy
cell = self.cells.get(cell, cell)
gdspy.current_li... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract(self, cell):\n cell = self.cell_dict.get(cell, cell)\n current_library.add(cell)\n current_library.add(cell.get_dependencies(True))\n return cell",
"def import_gds(filename, cellname = None, flatten = False):\n gdsii_lib = gdspy.GdsLibrary()\n gdsii_lib.read_gds(file... | [
"0.7146233",
"0.5359825",
"0.53328305",
"0.52091736",
"0.5137022",
"0.51339316",
"0.5118252",
"0.5001852",
"0.49921566",
"0.4971133",
"0.49391878",
"0.4921173",
"0.49046072",
"0.48940232",
"0.48588583",
"0.48488533",
"0.48184195",
"0.4751385",
"0.47495297",
"0.4736816",
"0.47... | 0.6714337 | 1 |
Write the specified cell to the file. | def write_cell(self, cell, timestamp=None):
cell.to_gds(self._outfile, self._res, timestamp)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_cell(self, cell):\n self._outfile.write(cell.to_gds(self._res))\n return self",
"def writeCell(hoja, fila, columna, dato, formato=''):\r\n if formato:\r\n hoja.write(fila, columna, dato, formato)\r\n else:\r\n hoja.write(fila, columna, dato)",
"def write_cell(self, s... | [
"0.7893535",
"0.7167007",
"0.64020705",
"0.6233088",
"0.6106569",
"0.60965765",
"0.60965765",
"0.605748",
"0.59968483",
"0.59903365",
"0.5989713",
"0.5946001",
"0.59330434",
"0.58675724",
"0.5825177",
"0.58209854",
"0.58193207",
"0.57958156",
"0.5771627",
"0.5768062",
"0.5734... | 0.74768186 | 1 |
Write the specified binary cells to the file. | def write_binary_cells(self, binary_cells):
for bc in binary_cells:
self._outfile.write(bc)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_binary(self, path):\n return",
"def write_df_to_binary(file_name_mask, df):\n write_matrix_to_binary(file_name_mask + '-value.bin', df.values)\n with open(file_name_mask + '-name.txt', 'w') as f:\n f.write(\"\\t\".join(df.index))\n f.write(\"\\n\")\n f.write(\"\\t\".jo... | [
"0.65858525",
"0.6368011",
"0.6283617",
"0.622919",
"0.6155533",
"0.6013805",
"0.5996172",
"0.5971584",
"0.59386206",
"0.5921192",
"0.591766",
"0.5843438",
"0.58248633",
"0.5801343",
"0.578895",
"0.5729028",
"0.57093227",
"0.5703158",
"0.56399626",
"0.56187046",
"0.56164056",... | 0.8135084 | 0 |
Finalize the GDSII stream library. | def close(self):
self._outfile.write(struct.pack(">2H", 4, 0x0400))
if self._close:
self._outfile.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finalize(self):\r\n self.stream.finalize()",
"def finalize():",
"def finalize():",
"def finalize():",
"def finalize(self):\n # 027 Not needed in the simple FilesAdaptor. \n pass",
"def finalize(self):\r\n self.outfile_param.close()\r\n self.outfile_sim.close()",
"... | [
"0.7394158",
"0.6610522",
"0.6610522",
"0.6610522",
"0.660409",
"0.6511681",
"0.641157",
"0.63843083",
"0.63843083",
"0.63843083",
"0.63843083",
"0.63843083",
"0.63843083",
"0.6372242",
"0.6350792",
"0.6350792",
"0.63461405",
"0.63144404",
"0.63144404",
"0.6277247",
"0.622790... | 0.0 | -1 |
Return the unit and precision used in the GDS stream file. | def get_gds_units(infile):
close = True
if hasattr(infile, "__fspath__"):
infile = open(infile.__fspath__(), "rb")
elif isinstance(infile, (basestring, Path)):
infile = open(infile, "rb")
else:
close = False
unit = precision = None
for rec_type, data in _raw_record_reader... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_precision(self):\n ...",
"def unit_of_measurement(self) -> str:\n return FPS",
"def unit_of_measurement(self) -> str:\n return FPS",
"def unit_of_measurement(self):\n return self._metadata[1]",
"def GetDataPrecision():\n return _gmat_py.GmatBase_GetDataPrecision()... | [
"0.66406333",
"0.62469673",
"0.62469673",
"0.62245446",
"0.6159991",
"0.6155099",
"0.6046847",
"0.60281473",
"0.60199654",
"0.597692",
"0.597692",
"0.5961308",
"0.5957242",
"0.59303707",
"0.59269",
"0.5922502",
"0.5920388",
"0.58822894",
"0.5881604",
"0.5881604",
"0.5881604",... | 0.6897266 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.