def dmbiologist(pivotTable): pivotTableCOPY = arcpy.TableToTable_conversion(pivotTable, env.workspace, "pivotTableCOPY") with arcpy.da.UpdateCursor( pivotTableCOPY, ["dmproc", "total_records", "survey_site_dmstat"]) as cursor: for row in cursor: if row[0] == row[1] and (row[2] == "dmproc" or row[2] is None): cursor.deleteRow() else: pass refname = [ "hna", "geo", "lep", "eic", "tra", "dwa", "yea", "zim", "eaz", "alb", "kun", "mcp", "mil", "wis", "gip", "fur", "wal", "wat", "woo", "gle", "gru", "sch", "shc", "dav" ] createnames = [ "ahnatkovich", "bgeorgic", "bleppo", "ceichelberger", "ctracey", "dwatts", "dyeany", "ezimmerman", "ezimmerman", "jalbert", "jkunsman", "jmcpherson", "rmiller", "jwisgo", "kgipe", "mfuredi", "mwalsh", "dwatts", "pwoods", "rgleason", "sgrund", "sschuette", "sschuette", "ezimmerman" ] for ref, name in zip(refname, createnames): with arcpy.da.UpdateCursor(pivotTableCOPY, ["refcode", "created_by"]) as cursor: for row in cursor: if row[0] is None or row[1] is None: pass else: if (row[1].lower() == "arcgis" or row[1].lower() == "tjadmin" or row[1].lower() == "administrator" or row[1].lower() == "bgeorgic") and ref in row[0].lower(): row[1] = name cursor.updateRow(row) outPath = "P:\\Conservation Programs\\Natural Heritage Program\\" \ "Data Management\\Instructions, procedures and documentation\\FIND\\" \ "FIND_2016\\Reports\\Biologist Status Reports" with arcpy.da.SearchCursor(pivotTableCOPY, "created_by") as cursor: biologists = sorted({row[0] for row in cursor}) for biologist in biologists: if biologist is None: pass else: expression = "created_by = '{}'".format(biologist) tableTEMP = arcpy.TableToTable_conversion(pivotTableCOPY, "in_memory", "tableTEMP", expression) filename = biologist + " - " + "FIND Status Report " + time.strftime( "%d%b%Y") + ".xls" outTable = os.path.join(outPath, filename) arcpy.TableToExcel_conversion(tableTEMP, outTable) print "DM Biologist Report Created!"
def snap_transfers_to_network(transfer_shp_f, node_shp): arcpy.AddXY_management(node_shp) arcpy.TableToTable_conversion(node_shp, "C:/GIS/", "node.dbf", "", "", "") arcpy.TableToTable_conversion(transfer_shp, "C:/GIS/", "transfer.dbf", "", "", "") arcpy.JoinField_management("C:/GIS/transfer.dbf", "nearNID", "C:/GIS/node.dbf", "ID", ["POINT_X", "POINT_Y"]) # arcpy.Delete_management(transfer_shp_snapped) arcpy.MakeXYEventLayer_management("C:/GIS/transfer.dbf", "POINT_X", "POINT_Y", "new_transfer") arcpy.CopyFeatures_management("new_transfer", transfer_shp)
def dbf_2csv(GPS_date): for i in range(6): inputpath_141 = 'E:/MapMatch/Intersect_analysis/bh_141/201612%d/bh141_201612%d_%02d.dbf' % ( GPS_date, GPS_date, i) outputpath_141 = 'E:/MapMatch/dbf_2csv/bh_141/201612%d' % (GPS_date) inputpath_142 = 'E:/MapMatch/Intersect_analysis/bh_142/201612%d/bh142_201612%d_%02d.dbf' % ( GPS_date, GPS_date, i) outputpath_142 = 'E:/MapMatch/dbf_2csv/bh_142/201612%d' % (GPS_date) arcpy.TableToTable_conversion( inputpath_141, outputpath_141, 'bh141_201612%d_%02d.csv' % (GPS_date, i)) arcpy.TableToTable_conversion( inputpath_142, outputpath_142, 'bh142_201612%d_%02d.csv' % (GPS_date, i))
def Iniciar_valor(): path=os.path.dirname(os.path.abspath(__file__)) path_temp=path+"\\temp" arcpy.env.overwriteOutput = True #Datos_xls = "\Archivos Base de Datos\ENLACES.xls" arcpy.env.workspace = path+"/temp" if arcpy.Exists(path+"\\temp\\conversion.dbf"): arcpy.Delete_management(path+"\\tempo\\conversion.dbf") if arcpy.Exists(path+"\\temp\\conversion_1.dbf"): arcpy.Delete_management(path+"\\tempo\\conversion_1.dbf") if arcpy.Exists(path+"\\temp\\conversion_12.dbf"): arcpy.Delete_management(path+"\\tempo\\conversion_12.dbf") if arcpy.Exists(path+"\\temp\\salida.dbf"): arcpy.Delete_management(path+"\\tempo\\salida.dbf") if arcpy.Exists(path + "\\temp\\salida_1.dbf"): arcpy.Delete_management(path + "\\tempo\\salida_1.dbf") conversion = "conversion_1" #arcpy.ExcelToTable_conversion(path+Datos_xls, "conversion11_1") arcpy.TableToTable_conversion("table.dbf",path+"/temp",conversion) arcpy.TableToTable_conversion("table.dbf", path+"/temp", "salida_1") #Datos_xls = "\Archivos Base de Datos\DATA_PRUEBA.xls" #Datos_xls1 = "\Archivos Base de Datos\ENLACES.xls" arcpy.env.workspace = path + "/temp" conversion = "conversion" #arcpy.ExcelToTable_conversion(path + Datos_xls, "conversion11") arcpy.TableToTable_conversion(path_temp+"\\table.dbf", path + "/temp", conversion) arcpy.TableToTable_conversion(path_temp+"\\table.dbf", path + "/temp", "salida") arcpy.AddField_management("salida.dbf", "LATITUD_GD", "FLOAT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management("salida.dbf", "LONGITUD_GD", "FLOAT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") expression = "parse_dms(!Latitud!)" expression1 = "parse_dms(!Longitud!)" codeblock = """def parse_dms(dms): import re try: parts=re.split('[^\d\w\.]+',dms.encode('utf8')) dd=float(parts[0])+float(parts[1])/60.0+float(parts[2])/(3600.0); #print(parts[0]+","+","+parts[1]+","+parts[2]+","+parts[3]) if parts[3]=='W' or parts[3]=='S': dd*=-1 return dd except Exception as e: return 0""" arcpy.CalculateField_management("salida.dbf", "LATITUD_GD", expression, "PYTHON_9.3", codeblock) arcpy.CalculateField_management("salida.dbf", "LONGITUD_GD", expression1, "PYTHON_9.3", codeblock)
def zipCalc(inputDF, outLoc, commField, zipField): #make table into a csv to count unique town names outTable = "toCountTEMP.csv" arcpy.TableToTable_conversion(str(inputDF) + ".dbf", outLoc, outTable) readTable = str(outLoc) + "/" + str(outTable) tempDF = pd.read_csv(readTable) tempCol = tempDF[commField] uniqueZips = tempCol.unique() zipRef = pd.read_csv(outLoc+'/zipExp.csv') #list of values that can be ignored and not assigned a zip ignoreNames = ["SECTOR", "CELLULAR", "NOT AVAILABLE", "VOIP", "UNKNOWN"] for i in uniqueZips: var = str(commField) expression = "\"" + var + "\" = " + "'" + str(i) + "'" #"var" = 'zip' arcpy.MakeTableView_management(inputDF, "tempView") arcpy.SelectLayerByAttribute_management("tempView", "NEW_SELECTION", expression) #check if there's a matching town name in the zip code file try: temp = zipRef.loc[zipRef.NAME == str(i).title(), "POSTAL"] #checks if the community can have more than one zip code if temp.size > 1: print(str(i) + " can have multiple zip codes") zipCode = raw_input("Please enter the zip code: ") else: zipCode = str(zipRef.loc[zipRef.NAME == str(i).title(), "POSTAL"].values[0]) zipCode = zipCode[0:5] except: if str(i).upper() in ignoreNames: continue else: zipCode = raw_input("Please enter the zip code for " + str(i) + ": ") arcpy.CalculateField_management("tempView", "Zip", "'" + zipCode + "'", "PYTHON_9.3") print("Zip code for " + i + " assigned") removeRow(inputDF, "Zip", "99999")
def mergeFeatureClasses( ): #arcpy.management.Merge(mfileList, r"D:\data\covid\MyProject.gdb\capstoneStates", '', "NO_SOURCE_INFO") #r"D:\data\covid\CO_20201103\\"+"Ugn"+tdate+".gdb\\"+"Ugn"+tdate+"EHSA try: for x in capstoneStates: mfileList.append(r"D:\data\covid\\" + "Ugn" + tdate + "\\" + "Ugn" + tdate + ".gdb\\" + "cases" + str(int(tdate) - 1) + "EHSA") for file in mfileList: print(file) if arcpy.Exists(r"D:\data\covid\capstoneStates.gdb\capstoneStates"): arcpy.Delete_management( r"D:\data\covid\capstoneStates.gdb\capStates") print( "Exists D:\data\covid\capstoneStates.gdb\capstoneStates", arcpy.Exists( r"D:\data\covid\capstoneStates.gdb\capstoneStates")) arcpy.management.Merge( mfileList, r"D:\data\covid\capstoneStates.gdb\capstoneStates" + "Ugn" + tdate, '', "NO_SOURCE_INFO") arcpy.management.AddIndex( r"D:\data\covid\capstoneStates.gdb\capstoneStates" + "Ugn" + tdate, "GEONUM", "GEONUM", "NON_UNIQUE", "NON_ASCENDING") patternCount = os.path.join(r"D:\data\covid", "patternCount" + tdate + ".csv") arcpy.TableToTable_conversion( patternCount, r"D:\data\covid\capstoneStates.gdb", "patternCount" + "Ugn" + tdate) #Table To Table conversion except: getTraceback()
def main(): startTime = dt.datetime.now() print("Script run at {0}.".format(startTime)) p = Path(__file__).parents[0] # `Scenario_1024` should be changed to the appropriate scenario number # output by Emme. links_shapefile = os.path.join(str(p), 'New_Project', 'Media', 'Scenario_1024', 'emme_links.shp') in_field = 'ID' join_table = os.path.join(str(p), 'volumes.csv') join_field = 'UNIQUEID' arcpy.TableToTable_conversion(join_table, str(p), 'volumes_converted.dbf' ) converted_table = os.path.join(str(p), 'volumes_converted.dbf') joined_file = arcpy.JoinField_management( links_shapefile, in_field, converted_table, join_field) arcpy.FeatureClassToShapefile_conversion(joined_file, os.path.join(str(p))) endTime = dt.datetime.now() print("Script finished in {0}.".format(endTime - startTime))
def responseToTable(self, table): ''' :param table: Feature o tabla que se esta evaluando :return: Crea un tabla temporal en el SCRATCH gdb ''' array = [ x.get('attributes') for x in self.jsonresponse.get('features') ] self.identifiers = [[x.get('globalid'), x.get('objectid')] for x in array] self.identifiers.sort(key=lambda x: x[1]) pth = os.path.join(self.scratch, 'temp') feature = arcpy.AsShape(self.jsonresponse, True) if table.split("_")[0] == "GPT": self.copy = arcpy.CopyFeatures_management(feature, pth) arcpy.management.AddField(self.copy, "EVENTID", "GUID") n = 0 with arcpy.da.UpdateCursor(self.copy, ["EVENTID"]) as cursorU: for row in cursorU: mmm = self.identifiers[n][0].upper() row[0] = u'{}'.format('{' + mmm + '}') cursorU.updateRow(row) n = n + 1 del cursorU self.listaCDMTRA = [[x[0], x[1]] for x in arcpy.da.SearchCursor( self.copy, ["EVENTID", self.CDMTRA])] arcpy.DeleteField_management(self.copy, "globalid") if table.split("_")[0] == "TB": self.copy = arcpy.TableToTable_conversion( feature, self.scratch, '{}a{:.5}'.format(table, str(uuid.uuid4())))
def CreateXwalkTable(UPConfig, ZonalDataset, ZoneField, MaxDist): ##Makes a Xwalk table between zone ID and BaseGeom ID #set the workspace UPGDB = os.path.join(UPConfig['paths']['dbpath'], UPConfig['paths']['dbname']) env.workspace = UPGDB env.overwriteOutput = True ##create a crosswalk table between zones and BaseGeomIDs #join base geom centroids to zonal layer arcpy.SpatialJoin_analysis( os.path.join(UPConfig['paths']['dbpath'], UPConfig['paths']['dbname'], UPConfig['BaseGeom_cent']), os.path.join(UPConfig['paths']['dbpath'], UPConfig['paths']['dbname'], ZonalDataset), "in_memory/intersect", "JOIN_ONE_TO_ONE", "KEEP_ALL", "", "CLOSEST", MaxDist) #create XWalk table if arcpy.Exists('upa_ZoneXWalk'): arcpy.Delete_management('upa_ZoneXWalk') arcpy.TableToTable_conversion('in_memory/intersect', UPGDB, 'upa_ZoneXWalk') #delete unneeded fields BaseGeomID = UPConfig['BaseGeom_id'] Fields = arcpy.ListFields("upa_ZoneXWalk") FieldList = [] for Field in Fields: if not Field.required: if not (Field.name == BaseGeomID or Field.name == ZoneField): FieldList.append(Field.name) arcpy.DeleteField_management("upa_ZoneXWalk", FieldList)
def AddressCheck(table, Workspace, addr): arcpy.AddField_management(table, "FieldError", "TEXT") rows = arcpy.UpdateCursor(table) check = False try: for row in rows: if "-" in row.getValue(addr): check = True row.FieldError = "ERROR" rows.updateRow(row) else: row.FieldError = "None" rows.updateRow(row) del row del rows except: del rows if check == True: arcpy.AddMessage("Field errors found!") expression = arcpy.AddFieldDelimiters(table, "FieldError") + " = 'ERROR'" arcpy.TableToTable_conversion(table, Workspace, "Address_Errors.dbf", expression) rows = arcpy.UpdateCursor(table) for row in rows: if row.getValue("FieldError") == "ERROR": rows.deleteRow(row) del row del rows
def createSumTbl(table): # Calculate the Attribute Fields for the Cloned DCN Data arcpy.Statistics_analysis(table, table + "_area_v1", [[ "Shape_Area", "SUM", ]], "SUMAREA") arcpy.Statistics_analysis(table, table + "_provtot_v1", [[ "SUMPROV", "FIRST", ]], "SUMPROV") arcpy.AddField_management(table + "_area_v1", "VERSION", "TEXT", "", "", "50", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(table + "_area_v1", "AREADBL", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(table + "_area_v1", "AREADBL", "round(!SUM_Shape_Area!/1000000, 0)", "PYTHON", "") arcpy.CalculateField_management(table + "_area_v1", "SUMAREA", calcSumFldArea, "PYTHON", "") arcpy.AddField_management(table + "_provtot_v1", "VERSION", "TEXT", "", "", "50", "", "NULLABLE", "NON_REQUIRED", "") if tblName == "tbl_temp_web_prov_tot_cur": arcpy.TableToTable_conversion(table + "_area_v1", outFolder, tblFinalSum) arcpy.CalculateField_management(table + "_area_v1", "VERSION", "'" + "CURRENT" + "'", "PYTHON") arcpy.CalculateField_management(table + "_provtot_v1", "VERSION", "'" + "CURRENT" + "'", "PYTHON") elif tblName == "tbl_temp_web_prov_tot_prev": arcpy.CalculateField_management(table + "_area_v1", "VERSION", "'" + "PREVIOUS" + "'", "PYTHON") arcpy.CalculateField_management(table + "_provtot_v1", "VERSION", "'" + "PREVIOUS" + "'", "PYTHON")
def patternEHSA(): try: arcpy.env.workspace = r"D:\data\covid\cases\aug_Oct2020\aug_Oct2020.gdb" newfolder = r"D:\data\covid\cases\aug_Oct2020" feature_classes = arcpy.ListFeatureClasses() df3 = pd.DataFrame(columns=['GEONUM', 'CATEGORY', 'PATTERN', 'DATE']) for fc in feature_classes: if fc.title() != ('Ctyprj'): print(fc.title()) fileDate = dt.datetime.strptime(fc[5:13], '%Y%m%d') field_names = [ i.name for i in arcpy.ListFields(fc) if i.type != 'OID' ] # Open a cursor to extract results from stats table cursor = arcpy.da.SearchCursor(fc, field_names) # Create a pandas dataframe to display results df = pd.DataFrame(data=[row for row in cursor], columns=field_names, dtype=int) df2 = df[['GEONUM', 'CATEGORY', 'PATTERN']] df2['DATE'] = fileDate df3 = df3.append(df2) # df3.rename(columns={"GEONUM": "FIPS"},inplace=True) patternCSV = os.path.join(newfolder, 'patternEHSA' + tdate + ".csv") df3.to_csv(patternCSV, sep=',', index=None, header=1) arcpy.TableToTable_conversion(patternCSV, arcpy.env.workspace, os.path.basename(patternCSV).replace( '.csv', '')) #Table To Table conversion return except: getTraceback()
def zone(zone, raster, temp_table, outpath_final, dbf): start_zone = datetime.datetime.now() arcpy.MakeRasterLayer_management( r'L:\Workspace\ESA_Species\Step3\Step3_Proposal\GAP\layerfiles_use_to_change_legend_in _ArcMap\6EcolSys_landuse.lyr', "snap") arcpy.env.snapRaster = "snap" arcpy.CreateTable_management("in_memory", temp_table) temp = "in_memory" + os.sep + temp_table arcpy.env.overwriteOutput = True arcpy.gp.ZonalHistogram_sa(zone, "Value", raster, temp) try: arcpy.AddField_management(temp, 'TableID', "TEXT", "", "", "100", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(temp, "TableID", "!OBJECTID!", "PYTHON_9.3", "") except: pass print "Completed Zonal Histogram" try: arcpy.TableToTable_conversion(temp, outpath_final, dbf) except: pass list_fields = [f.name for f in arcpy.ListFields(temp)] att_array = arcpy.da.TableToNumPyArray((temp), list_fields) att_df = pd.DataFrame(data=att_array) return att_df, start_zone
def FCtoTXT(fc, txtloc, outtxt): env.workspace = txtloc arcpy.env.overwriteOutput = True fc_view = arcpy.MakeTableView_management(fc, 'fc_view') arcpy.TableToTable_conversion(fc_view, txtloc, outtxt) del fc_view print("text file {} created".format(outtxt))
def add_itm_cor_to_csv_file(self): fc_file = self.name_gis arcpy.management.XYTableToPoint( self.gps_file, fc_file, "lon", "lat", coordinate_system=arcpy.SpatialReference(4326)) obj_name_pro = fc_file + '_pro' # Process: Project arcpy.Project_management( in_dataset=fc_file, out_dataset=obj_name_pro, out_coor_system=arcpy.SpatialReference(2039), transform_method="WGS_1984_To_Israel_CoordFrame", in_coor_system=arcpy.SpatialReference(4326), preserve_shape="NO_PRESERVE_SHAPE", max_deviation="", vertical="NO_VERTICAL") # Process: Add Geometry Attributes arcpy.AddGeometryAttributes_management( Input_Features=obj_name_pro, Geometry_Properties="POINT_X_Y_Z_M", Length_Unit="METERS", Area_Unit="", Coordinate_System="") # Process: Table To Table arcpy.TableToTable_conversion(obj_name_pro, self.workspace_csv_progress, fc_file + 'itm.csv')
def oracleXY2oracle(sourceLyr, tempName, targetLyr, X, Y): now = datetime.datetime.now() arcpy.AddMessage('--- Przetwarzanie zasilania Oracle [' + now.strftime("%Y/%m/%d %H:%M:%S") + '] ---') inputs = [oracle_hydro_sdo + "\\" + sourceLyr] temps = [myPath + "tempGDB.gdb\\" + tempName] #targets = [baza4Connector + "\\" + targetLyr] targets = [oracle_hydro_sdo + "\\" + targetLyr] fieldX = [X] fieldY = [Y] events = ["tempLyr"] i = 0 for n in inputs: arcpy.AddMessage(' --> Kopiowanie tabeli tempTable' + tempName) arcpy.TableToTable_conversion(n, myPath + "tempGDB.gdb", "tempTable" + tempName) arcpy.AddMessage(' --> Tworzenie warstwy przestrzennej ' + temps[i]) arcpy.MakeXYEventLayer_management( myPath + "tempGDB.gdb\\tempTable" + tempName, fieldX[i], fieldY[i], events[i], spatialRef, "") arcpy.FeatureClassToFeatureClass_conversion(events[i], myPath + "tempGDB.gdb\\", tempName) arcpy.AddMessage(' --> Usuwanie danych z ' + targets[i]) arcpy.DeleteRows_management(targets[i]) arcpy.AddMessage(' --> Zasilanie danych do ' + targets[i]) arcpy.Append_management(temps[i], targets[i], "NO_TEST", "", "") i = i + 1
def fields_to_table(input_data, fields, workspace, output_table): '''function creates field mappings object then uses the table to tables conversion tool to export a table to your gdb from your FC fields :param input_data: your feature class in your geodatabase :param fields: a list of your field names (string) :param workspace: your arcpy.env.workspace :output_table: the name of your output table''' #create empty field mapping object fms = arcpy.FieldMappings() #define fieldmaps and add to field mapping objects (fms) for field in fields: fm = arcpy.FieldMap() fm.addInputField(input_data, field) output_field = fm.outputField output_field.name = field fm.outputField = output_field # add the field map to the field mappings object fms.addFieldMap(fm) #print field map object print(fms) #run table to table conversion tool with field mappings parameter arcpy.TableToTable_conversion(input_data, workspace, output_table, "", fms) print("converted %s to table" %(input_data))
def test_table_to_polygon_w_grouping(self): '''Test Table To Polygon using Name field as the grouping Line Field''' Configuration.Logger.info(".....TableToPolygonTestCase.test_table_to_polygon_w_grouping") # Delete the output feature class if already exists if arcpy.Exists(self.outputPolygons) : arcpy.Delete_management(self.outputPolygons) # Note: tool fails when run with input "Name" and "Vsort" fields as params groupingFieldName = 'Name' toolOutput = arcpy.TableToPolygon_mt(self.inputTable, "DD_2", "POINT_X", "POINT_Y", self.outputPolygons, groupingFieldName, "Vsort") # 1: Check the expected return value self.assertIsNotNone(toolOutput, "No output returned from tool") outputOut = toolOutput.getOutput(0) self.assertEqual(self.outputPolygons, outputOut, "Unexpected return value from tool") self.assertTrue(arcpy.Exists(self.outputPolygons), "Output features do not exist or were not created") # Process to check tool results for Grouping # Step 1: Make in_memory table to get frequency of inMemTable = arcpy.TableToTable_conversion(self.inputTable, "in_memory", "TableToPolygon_single_In_Mem") # Step 2: Get the frequency of unique "group values" in the input table # Get Frequency of the unique names in the input table freqInputTable = arcpy.Frequency_analysis(inMemTable, "in_memory\\CountOfUniqueNames", groupingFieldName, "") # Get Count of the unique names freqTableCount = arcpy.GetCount_management(freqInputTable) expectedFeatureCount = int(freqTableCount.getOutput(0)) polygonCount = int(arcpy.GetCount_management(self.outputPolygons).getOutput(0)) self.assertEqual(polygonCount, expectedFeatureCount, "Expected %s features, but got %s" % (str(expectedFeatureCount), str(polygonCount))) return
def attribute_from_vector(feat, obj, field, id_index): gdb_path = os.path.dirname(os.path.abspath(feat)) arcpy.env.workspace = '{}'.format(os.path.dirname(os.path.abspath(gdb_path))) arcpy.env.overwriteOutput = True arcpy.env.qualifiedFieldNames = False temp_folder = r'{}\temp'.format(os.path.dirname(os.path.abspath(gdb_path))) if os.path.exists(temp_folder): gp.AddMessage('folder temp already exists') else: gp.AddMessage('Making temp folder') os.mkdir(temp_folder) # check if the 'to' field exists and if not found then add it if len(arcpy.ListFields(feat, field)) == 0: gp.AddMessage('the {} field does not exist'.format(field)) else: gp.AddMessage('The {} field already exits ... Deleting'.format(field)) arcpy.DeleteField_management(feat, field) gp.AddMessage('Intersect Analysis') arcpy.Intersect_analysis(in_features='{} #;{} #'.format(feat, obj), out_feature_class='{}/UTTL_Basins_Intersect'.format(temp_folder), join_attributes='NO_FID', cluster_tolerance="-1 Unknown", output_type='INPUT') arcpy.AddField_management('{}/UTTL_Basins_Intersect.shp'.format(temp_folder), "Up_Area", "DOUBLE") exp = "!SHAPE.AREA@SQUAREKILOMETERS!" arcpy.CalculateField_management('{}/UTTL_Basins_Intersect.shp'.format(temp_folder), "Up_Area", exp, "PYTHON_9.3") arcpy.TableToTable_conversion('{}/UTTL_Basins_Intersect.shp'.format(temp_folder), temp_folder, 'UTTL_Basins_Intersect.csv') field = check_arcmap_field(field) df_table = pd.read_csv('{}/UTTL_Basins_Intersect.csv'.format(temp_folder))[[id_index, field, 'Up_Area']] idx = df_table.groupby(by=id_index, sort=False)['Up_Area'].transform(max) == df_table['Up_Area'] df_sel_table = df_table[idx] df_join_table = df_sel_table.copy() df_join_table['Code'] = [str(i) for i in df_sel_table[id_index]] df_join_table.drop(labels=[id_index, 'Up_Area'], axis=1, inplace=True) df_join_table.columns = [field, id_index] df_join_table.to_csv('{}/UTTL_Basins_NewVectorAttribute.csv'.format(temp_folder)) arcpy.AddField_management(feat, field, 'TEXT') x = np.array(np.rec.fromrecords(df_join_table.values)) names = map(str, df_join_table.dtypes.index.tolist()) x.dtype.names = tuple(names) arcpy.da.NumPyArrayToTable(x, r'{}\{}'.format(gdb_path, field)) # joins are annoying but you #should# be able to do it this way # joins must be performed on a Layer or Table View object... arcpy.MakeFeatureLayer_management(feat, 'Layer') arcpy.AddJoin_management('Layer', id_index, r'{}\{}'.format(gdb_path, field), id_index) arcpy.CalculateField_management('Layer', field, '!{}.{}!'.format(field, field), 'PYTHON_9.3') gp.AddMessage('attribute {} added successfully'.format(field))
def Export_Level_1(output_workspace, flowline_points, xs, xs_points, features): # Set environment variables arcpy.env.overwriteOutput = True # Create the output folder parent_folder = os.path.dirname(output_workspace) output_workspace_basename = os.path.splitext(os.path.basename(output_workspace))[0] exports_folder = os.path.join(parent_folder, "exports") archive_folder = os.path.join(exports_folder, output_workspace_basename) arcpy.AddMessage("parent_folder: {}".format(parent_folder)) arcpy.AddMessage("output_workspace_basename: {}".format(output_workspace_basename)) arcpy.AddMessage("exports_folder: {}".format(exports_folder)) arcpy.AddMessage("archive_folder: {}".format(archive_folder)) if not os.path.exists(exports_folder): os.makedirs(exports_folder) arcpy.AddMessage("Created folder: {}".format(exports_folder)) if not os.path.exists(archive_folder): os.makedirs(archive_folder) arcpy.AddMessage("Created folder: {}".format(archive_folder)) if flowline_points: arcpy.TableToTable_conversion(in_rows = flowline_points, out_path = archive_folder, out_name = "flowline_points.csv") if xs: xs_basename = os.path.splitext(os.path.basename(xs))[0] xs_csv = "{}.csv".format(xs_basename) arcpy.TableToTable_conversion(in_rows = xs, out_path = archive_folder, out_name = xs_csv) if xs_points: xs_points_basename = os.path.splitext(os.path.basename(xs_points))[0] xs_points_csv = "{}.csv".format(xs_points_basename) arcpy.TableToTable_conversion(in_rows = xs_points, out_path = archive_folder, out_name = xs_points_csv) if features: arcpy.TableToTable_conversion(in_rows = features, out_path = archive_folder, out_name = "features.csv")
def BackupAttachmentsData(AttachmentTable): ''' Function that creates a backup attachment table in a local database in the same location as this script. ''' Database = r"C:\Users\jamesd26.NETID\Desktop\GitHub\CampusEngineering\Python\Confidence Tests\Backup.gdb" OutTable = 'Attachments_' + str(datetime.date.today()).replace('-', '_') arcpy.TableToTable_conversion(AttachmentTable, Database, OutTable)
def create_braut_field(): # Create a temporary table in FGDB arcpy.TableToTable_conversion(InputFileTID, env.workspace, "temp_id_table") temp_table = env.workspace + "/temp_id_table" # needed because of tool bug # add BRAUT field with a join arcpy.JoinField_management(OutputBrautTemp, "OBJECTID", temp_table, "File_ID", ["BRAUT"]) arcpy.Delete_management(temp_table) # Delete temporary table
def convertDataset(dataElementType, sourceTable, workspace, targetName, whereClause): if dataElementType == "DEFeatureClass": arcpy.FeatureClassToFeatureClass_conversion(sourceTable, workspace, targetName, whereClause) elif dataElementType == "DETable": arcpy.TableToTable_conversion(sourceTable, workspace, targetName, whereClause)
def copy(): env.workspace = master_gdb for filename in germane_FCs: arcpy.FeatureClassToFeatureClass_conversion(filename, trans_gdb, filename) for tablename in germane_tables: arcpy.TableToTable_conversion(tablename, trans_gdb, tablename)
def mergetables(): '''function that converts shapefiles to tables and merges all tables''' for input, output in zip(elementShapefiles, elementTables): input_feature = os.path.join(env.workspace, input) arcpy.TableToTable_conversion(input_feature, env.workspace, output) merge = os.path.join(env.workspace, "elementRecords") arcpy.Merge_management(elementTables, merge)
def execute(self, parameters, messages): # create GDB folder = parameters[0].valueAsText name = parameters[1].valueAsText arcpy.CreateFileGDB_management(folder, name) gdb_path = folder + '\\' + name # create garages shapefile, add to GDB garage_location = parameters[3].valueAsText garage_shp_name = parameters[4].valueAsText garages = arcpy.MakeXYEventLayer_management(garage_location, 'X', 'Y', garage_shp_name) arcpy.FeatureClassToGeodatabase_conversion(garages, gdb_path) garage_path = gdb_path + '\\' + garage_shp_name # create buildings shapefile given the structures .shp in Campus campus_gdb_path = parameters[2].valueAsText structures = campus_gdb_path + '\Structures' campus_buildings = gdb_path + '\\' + 'campus_building' arcpy.Copy_management(structures, campus_buildings) # reproject garages to the spatial reference of campus buildings projection = arcpy.Describe(campus_buildings).spatialReference arcpy.Project_management(garage_path, gdb_path + '\garage_projected', projection) garage_projected = gdb_path + '\garage_projected' # get building to buffer and buffer distance garage_selection = parameters[5].valueAsText buffer_distance = float(parameters[6].valueAsText) # make sure garage exists where = "Name = '%s'" % garage_selection cursor = arcpy.SearchCursor(garage_projected, where_clause=where) shouldProceed = False for row in cursor: if row.getValue('Name') == garage_selection: shouldProceed = True # if should proceed = true if shouldProceed: # generate the name for buffer layer garage_buff = r'\garage_%s_buffed_%s' % (garage_selection, buffer_distance) # get reference to building garageFeature = arcpy.Select_analysis(garage_projected, gdb_path + r'building_%s' % (garage_selection), where) # buffer selected garage garage_buffered = arcpy.Buffer_analysis(garageFeature, gdb_path + garage_buff, buffer_distance) # intersection of garage buffer and campus buildings arcpy.Intersect_analysis([gdb_path + garage_buff, gdb_path + r'\campus_buildings'], gdb_path + '\garage_building_intersection', 'All') # convert to csv arcpy.TableToTable_conversion(gdb_path + '\garage_building_intersection.dbf', 'C:\\Users\\Eileen\\Documents\\lab 5', 'nearbyBuildings.csv') else: messages.addErrorMessage('garage not found') raise arcpy.ExecuteError return
def leerCsv(tabla): nameTb = tabla.split("\\")[-1].split("_")[0] tb = arcpy.TableToTable_conversion(tabla, pathgdb, "TB_" + nameTb) modifyCoords(tb) xyTmp = arcpy.MakeXYEventLayer_management( tb, "X", "Y", os.path.join(pathgdb, "TB_" + nameTb), arcpy.SpatialReference(4326)) copy = arcpy.CopyFeatures_management(xyTmp, os.path.join(pathgdb, nameTb)) return copy
def mergeDuplicatesNoHost(tableName, workspace): '''Takes the table of Expanded DCA values, where every row represents a unique record and combines the TPA for duplicates resulting from the same DCA value but different HOST values ''' mergedTableName = '{}_Merged'.format(tableName) countOfIDs = Counter(returnAllValuesFromField(tableName, 'ORIGINAL_ID')) if 2 in countOfIDs.values() or 3 in countOfIDs.values(): duplicatDict = {} cursor = arcpy.da.SearchCursor(tableName, ['ORIGINAL_ID', 'TPA'], 'DUPLICATE = 1') for row in cursor: if row[0] not in duplicatDict: duplicatDict[row[0]] = row[1] elif row[0] in duplicatDict: duplicatDict[row[0]] = row[1] + duplicatDict[row[0]] cursor = arcpy.da.SearchCursor(tableName, ['ORIGINAL_ID', 'TPA'], 'DUPLICATE = 1') duplicatDict = {row[0]: row[1] for row in cursor} if duplicatDict: arcpy.TableToTable_conversion(tableName, workspace, mergedTableName) arcpy.MakeTableView_management( os.path.join(workspace, mergedTableName), mergedTableName) cursor = arcpy.da.UpdateCursor(mergedTableName, ['ORIGINAL_ID', 'TPA'], 'DUPLICATE IS NULL') for row in cursor: if row[0] in duplicatDict.keys(): row[1] = row[1] + duplicatDict[row[0]] cursor.updateRow(row) arcpy.SelectLayerByAttribute_management(mergedTableName, "NEW_SELECTION", 'DUPLICATE = 1') arcpy.DeleteRows_management(mergedTableName) arcpy.SelectLayerByAttribute_management(mergedTableName, "CLEAR_SELECTION") else: arcpy.TableToTable_conversion(tableName, workspace, mergedTableName) return mergedTableName
def GDBAudit(GDBItems, GDBItemType, OutputLocation): # GDB Items to scratch table writelog(logFile, "Process: GDB Items to scratch table" + "\n") GDB_ITEMSTable = arcpy.TableToTable_conversion(GDBItems, arcpy.env.scratchGDB, "GDB_ITEMSTable", "", "", "") writelog(logFile, "Process: GDB Items to scratch table Complete!" + "\n") # Delete Fields writelog(logFile, "Process: Delete Fields" + "\n") GDB_ITEMSTable = arcpy.DeleteField_management(GDB_ITEMSTable, "Definition;Documentation") writelog(logFile, "Process: Delete Fields Complete!" + "\n") # GDB ITem Type to Scratch Table writelog(logFile, "Process: GDB ITem Type to Scratch Table" + "\n") GDB_ITEMTPYESTable = arcpy.TableToTable_conversion( GDBItemType, arcpy.env.scratchGDB, "GDB_ITEMTPYESTable", "", "", "") #arcpy.env.scratchGDB writelog(logFile, "Process: GDB ITem Type to Scratch Table Complete!" + "\n") # Run Join Field GDP tool to put the GDB_ITEMS table and the GDB_ITEMTYPES table together writelog( logFile, "Process: Run Join Field GDP tool to put the GDB_ITEMS table and the GDB_ITEMTYPES table together" + "\n") GDB_ITEMSTable = arcpy.JoinField_management(GDB_ITEMSTable, "Type", GDB_ITEMTPYESTable, "UUID", "Name;ParentTypeID") writelog( logFile, "Process: Run Join Field GDP tool to put the GDB_ITEMS table and the GDB_ITEMTYPES table together Complete!" + "\n") # Table to Excel Conversion tool writelog(logFile, "Table to Excel Conversion tool" + "\n") arcpy.TableToExcel_conversion(GDB_ITEMSTable, OutputLocation, "NAME", "CODE") writelog(logFile, "Table to Excel Conversion tool Complete!" + "\n") writelog(logFile, "Table Located: " + str(OutputLocation) + "\n")
def convert_to_temp_csv(features): """ Just a helper function that exports an ArcGIS table to a temporary csv file and returns the path :param features: :return: """ filepath = tempfile.mktemp(".csv", prefix="arcgis_csv_table") folder, filename = os.path.split(filepath) arcpy.TableToTable_conversion(features, folder, filename) return filepath