def ConvertMDBtoGDB(mdb, gdb): tables = [] featurs = [] FCs = ListFCinGDBorMDB(mdb) #print(FCs) for fc in FCs: ft = arcpy.Describe(mdb + '\\' + fc).dataElementType print(ft) if ft == 'DEFeatureClass': featurs.append(mdb + '\\' + fc) if ft == 'DETable': tables.append(mdb + '\\' + fc) if os.path.exists(gdb): try: shutil.rmtree(gdb) except Exception as e: print(e) pass arcpy.CreateFileGDB_management(os.path.dirname(gdb), os.path.basename(mdb).split('.')[0]) if len(featurs) > 0: arcpy.FeatureClassToGeodatabase_conversion(featurs, gdb) if len(tables) > 0: arcpy.TableToGeodatabase_conversion(tables, gdb) outL = featurs outL.extend(tables) return (outL)
def get_count(csv_fname, ws, countyName, parcel_name_field, map_name_field): '''converst the csv that was created into a dict PARCELID as key and MAP_NAME count as value then counts the number of Pages for each PARCELID''' print('Now going to get the count \n') try: conversion_fname = os.path.abspath(os.path.dirname(csv_fname)) except: csv_fname = str(csv_fname) conversion_fname = os.path.abspath(os.path.dirname(csv_fname)) #apperently this is a list object? #creating dict with no duplicates counts_dict = dict() df = pd.read_csv(csv_fname) df1 = df[[parcel_name_field, map_name_field]] #creates data frame with just ParcelID and MAP_NAME print('Number of rows is: ', df1.shape[0]) df2 = df1.drop_duplicates() print('After removing duplicates, number of rows is: {}'.format(df2.shape[0]) + '\n') for item in df2[parcel_name_field]: #loops through PARCELID column PARCELID = str(item) counts_dict[PARCELID] = counts_dict.get(PARCELID,0) + 1 #adds Count to ParcelID (dict key) or creates new ParcelID key if not already found with open(conversion_fname + '\\' + countyName + '_poly_count.csv', 'wb') as op_file: #writes poly_count.csv dict_writer = csv.writer(op_file) dict_writer.writerow([parcel_name_field, 'Poly_Count']) #creates headers for key, value in counts_dict.items(): dict_writer.writerow(["'" + key + "'", value]) #loops through dictionary and writes the key (PARCELID) & values (Poly_Count) op_file.close() op_file = conversion_fname + '\\' + countyName + '_poly_count.csv' csv_to_geodb = arcpy.TableToGeodatabase_conversion(op_file, ws) print("All Done.")
def archive(): # DCA - this should really be broken out into inputs vs outputs folders so its not all lumped together log("Archiving WHI inputs and outputs") # create new geodatabse archive_gdb = "WHI_archive_" + datetime.datetime.now().strftime('%Y%m%d') full_path = os.path.join(config.archive_loc, archive_gdb + ".gdb") if arcpy.Exists(full_path) == False: arcpy.CreateFileGDB_management(config.archive_loc, archive_gdb) # copy input files into geodatabase log("...archiving inputs") # vector sources for fc in config.vect_archive_list: if arcpy.Exists(fc) == True: log("......vectors") arcpy.FeatureClassToGeodatabase_conversion( config.vect_archive_list, full_path) return else: return str(fc) + " not found" # exclude these for now - they are going to be pretty static and take forever to copy ## # raster sources ## for fc in config.rast_archive_list: ## if arcpy.Exists(fc) == True: ## log("......rasters") ## arcpy.RasterToGeodatabase_conversion(config.rast_archive_list, full_path) ## else: ## return str(fc) + " not found" # copy output files into geodatabase log("...archiving outputs") # table outputs log("......tables") arcpy.env.workspace = config.primary_output tables = arcpy.ListTables() arcpy.TableToGeodatabase_conversion(tables, full_path) # feature class outputs log("......feature class(es)") fcs = arcpy.ListFeatureClasses() arcpy.FeatureClassToGeodatabase_conversion(fcs, full_path) log("Archiving complete")
def tableTo_primaryOutput(input_object): log("Copy result table to primary output gdb") desc = arcpy.Describe(input_object) if desc.dataElementType <> 'DETable': # if not a table - convert fc to table table_view = arcpy.MakeTableView_management(input_object, desc.basename) # move table to primary output gdb full_output_name = os.path.join(config.primary_output, desc.basename) arcpy.TableToGeodatabase_conversion(table_view, config.primary_output) else: # if already a table - copy table to primary output gdb full_output_name = os.path.join(config.primary_output, desc.basename) arcpy.Copy_management(input_object, full_output_name)
def select_and_copy_table(self, gdb_full_path_name, id_list, input_data, rename_basename, test_field): table_view_name = "table_view_selection" table_view_selection = arcpy.MakeTableView_management(input_data, table_view_name, "{0} in ({1})".format( test_field, self.utility.format_list_for_where_clause(id_list)) ) if arcpy.GetCount_management(table_view_selection) > 0: arcpy.AddMessage("...Copying table to gdb") arcpy.TableToGeodatabase_conversion(table_view_selection, gdb_full_path_name) arcpy.Rename_management(os.path.join(gdb_full_path_name, table_view_name), rename_basename) del table_view_selection else: pass
def ImportReDevTable(InTable, UPlanGDB, LongName, PopField, EmpField): ''' *Imports a redevelopment table to the GDB *Adds Redev keys to the upc_key table *Adds a record to the upc_layers table for this redev table Calls: AddToUPC_Layers Called by: Import Redevelopment Table Toolbox Arguments: InTable: The table to be added to the GDB UPlanGDB: The UPlan GDB (where the table will be imported) LongName: The descriptive name of the table PopField: Field that contains the number of people EmpField: Field that contains the number of employees Returns: None ''' # Set workspace env.workspace = UPlanGDB RedevTableName = os.path.basename(InTable) #Add table to geodatabase arcpy.TableToGeodatabase_conversion(InTable, UPlanGDB) #update upc_key table with redev info UpdateUPCKeyTable(UPlanGDB, 'Redev', RedevTableName) UpdateUPCKeyTable(UPlanGDB, 'Redev_pop', PopField) UpdateUPCKeyTable(UPlanGDB, 'Redev_emp', EmpField) #add redev table to layer tracker table AddToUPC_Layers(UPlanGDB, RedevTableName, LongName, 'RedevTable')
#Note: 2015 census shapefile cannot be used to join data as some county names and FIPS have been changed since census 2010 #And Devineni et al. 2015 used 2010 census counties county = projdir + "data/flood/Population/gz_2010_us_050_00_5m/gz_2010_us_050_00_5m.shp" NDImax = projdir + "data/scarcity/Devineni_et_al_2015/NDC_NDImax.csv" db_scarcity = "water_Scarcity/Gage_analysis_scarcity.gdb" NDImax_db = db_scarcity + "\NDC_NDImax" #Generate FIPS for counties to have a common key with Devineni's data arcpy.AddField_management(county, "FIPS", "TEXT") with arcpy.da.UpdateCursor(county, ['STATE', "COUNTY", 'FIPS']) as cursor: for row in cursor: row[2] = row[0] + row[1] cursor.updateRow(row) #Export csv to geodatabase arcpy.TableToGeodatabase_conversion(NDImax, db_scarcity) #Convert FIPS to string in NDImax table arcpy.AddField_management(NDImax_db, "FIPS_str", "TEXT") with arcpy.da.UpdateCursor(NDImax_db, ['FIPS', "FIPS_str", ""]) as cursor: for row in cursor: if row[0] < 10000: row[1] = "0" + str(row[0]) else: row[1] = str(row[0]) cursor.updateRow(row) #NDImax and NDC are strangely formatted, include "NaN" and 095.02E-05 and things of the like, so need to be formatted. arcpy.AddField_management(NDImax_db, "NDImax_numb", "DOUBLE") arcpy.AddField_management(NDImax_db, "NDC_numb", "DOUBLE") with arcpy.da.UpdateCursor(
row = rows.newRow() row.setValue(table_field_name1, i[0]) row.setValue(table_field_name2, i[1]) row.setValue(table_field_name3, i[2]) row.setValue(table_field_name4, i[3]) row.setValue(table_field_name5, i[4]) row.setValue(table_field_name6, i[5]) row.setValue(table_field_name7, i[6]) rows.insertRow(row) del row del rows # Export files to new geodatabase arcpy.FeatureClassToGeodatabase_conversion(polygon_name, output_gdb_path) arcpy.RasterToGeodatabase_conversion(depth_grid_name, output_gdb_path) arcpy.TableToGeodatabase_conversion(table_name, output_gdb_path) # Delete files from workspace arcpy.Delete_management(polygon_name) arcpy.Delete_management(table_name) arcpy.Delete_management(depth_grid_name) #Delete temporary files and variables if delete_intermediate_data == True: arcpy.AddMessage("Deleting temporary files for {0}".format(stage)) arcpy.Delete_management(TIN) del TIN arcpy.Delete_management(RasterFromTIN) del RasterFromTIN arcpy.Delete_management(Subtracted) del Subtracted
destination_path = "D:\Progetti_python\Verona\Sentinel1\BACKSCATTER\ImmaginiBackScatter\MergeIw1Iw2\Statistica_zonale\VH" for k in rasters: outRaster = os.path.join(destination_path, "D_" + k[0:11] + ".dbf") z = arcpy.gp.ZonalStatisticsAsTable_sa( "D:\\ArcGISProjects\\Verona\\Backscatter.gdb\\Uso_suolo_backscatter_iw1_VH", "Id", k, outRaster, "DATA", "MEAN") print(str(k[0:8]), "_____done.") arcpy.env.workspace = "D:\Progetti_python\Verona\Sentinel1\BACKSCATTER\ImmaginiBackScatter\MergeIw1Iw2\Statistica_zonale\VH" outLocation = "D:\ArcGISProjects\Verona\Backscatter.gdb" tablesmove = arcpy.ListTables() for table in tablesmove: if "D_2018" in table: arcpy.TableToGeodatabase_conversion(table, outLocation) else: print(table) #Cambia nomi arcpy.env.workspace = "D:\\ArcGISProjects\\Verona\\Backscatter.gdb" tables = arcpy.ListTables() for fc in tables: if "D_2018" in fc: fieldList = arcpy.ListFields(fc) new_name = fc new_name2 = fc for field in fieldList: if field.name == 'MEAN': arcpy.AlterField_management(fc, field.name, new_name2, new_name2)
for reach in reach_list: PercentArea = [ row[0] for row in arcpy.da.SearchCursor( "{0}_Hypsometry".format(reach), "Percent_Area") ] with arcpy.da.UpdateCursor( "hypsometry_all", ["{0}_Percent_Area".format(reach)]) as cursor: n = 0 for row in cursor: row[0] = PercentArea[n] cursor.updateRow(row) n += 1 # Export files to new geodatabase arcpy.TableToGeodatabase_conversion("Hypsometry_all", output_gdb_path) arcpy.RasterToGeodatabase_conversion(depth_grid_name, output_gdb_path) arcpy.RasterToGeodatabase_conversion("Hypsometry", output_gdb_path) for reach in reach_list: arcpy.RasterToGeodatabase_conversion("{0}_Hypsometry".format(reach), output_gdb_path) # Delete files from workspace arcpy.Delete_management("Hypsometry_all") arcpy.Delete_management(depth_grid_name) arcpy.Delete_management("Hypsometry") for reach in reach_list: arcpy.Delete_management("{0}_Hypsometry".format(reach)) # Delete temporary files and variables if delete_intermediate_data == True:
writer.writerow(['OBJECTID', 'filename']) for path, dirs, files in os.walk("P:/zip"): for filename in files: x = x + 1 writer.writerow([x, filename]) ############# Copy text data into the default geodatabase ############# # Set local variables to copy ws = 'C:/Users/' + usr + '/Documents/' db = 'C:/Users/' + usr + '/Documents/ArcGIS/Default.gdb' # create a list of new tables arcpy.env.workspace = ws newTables = arcpy.ListTables('*cleanup*') # create a list of old tables arcpy.env.workspace = db oldTables = arcpy.ListTables('*cleanup*') # delete existing tables print('Deleting current tables.') for i in oldTables: print('Deleting ' + i) arcpy.Delete_management(i) # import both tables print("Importing tables to gdb: " + db) for table in newTables: table = ws + table arcpy.TableToGeodatabase_conversion(table, db)
# Copyright © Scott Stopyak 2013 # Licence: Distributed under the terms of GNU GPL #_________________________________________________________________________________ import os, sys, arcpy inTable = arcpy.GetParameterAsText(0) prefix = arcpy.GetParameterAsText(1) outfolder = arcpy.GetParameterAsText(2) arcpy.env.overwriteOutput = True try: arcpy.CreateFileGDB_management(outfolder, "PrefixFields") gdb = os.path.join(outfolder, "PrefixFields.gdb") arcpy.RefreshCatalog(outfolder) inTableName = os.path.splitext(os.path.basename(inTable))[0] arcpy.TableToGeodatabase_conversion(inTable, gdb) table = os.path.join(gdb, os.path.splitext(os.path.basename(inTable))[0]) arcpy.RefreshCatalog(outfolder) except: pass fields = arcpy.ListFields(table) for f in fields: try: name = prefix + f.name type = f.type arcpy.AddField_management(table, name, type) exp = "!%s!" % (f.name) arcpy.CalculateField_management(table, name, exp, "PYTHON") arcpy.RefreshCatalog(outfolder) arcpy.DeleteField_management(table, [f.name])
def goNational(): geocodeOption = raw_input("Geocode Results? (Yes or No): ") if geocodeOption.lower() == 'n' or geocodeOption.lower() == 'no': fGDBnational(projectFolder, csvName) for stateX in stateList: listX = [] http = url_1 + what + url_2 + stateX url = http nationalScrapeNOGeocode(url, listX) page_number = 2 while page_number < (pages + 1): url = http + "&page=" + str(page_number) nationalScrapeNOGeocode(url, listX) page_number += 1 writeCSV(tempFolder, stateX, listX) # All CSVs added to fgdb as a table for stateX in stateList: arcpy.TableToGeodatabase_conversion( tempFolder + '/' + stateX + '.csv', projectFolder + '/' + csvName + '_National.gdb') del env.workspace env.workspace = projectFolder + '/' + csvName + "_National.gdb" tableList = arcpy.ListTables() tableMerge = [] for table in tableList: tableMerge.append(table) arcpy.Merge_management(tableMerge, csvName + "_National") inTable = csvName + "_National" out_xls = projectFolder + '/' + csvName + "_National.xls" arcpy.TableToExcel_conversion(inTable, out_xls) elif geocodeOption.lower() == 'y' or geocodeOption.lower( ) == 'yes': fGDBnational(projectFolder, csvName) for stateX in stateList: listX = [] http = url_1 + what + url_2 + stateX url = http nationalScrape(url, listX) page_number = 2 while page_number < (pages + 1): url = http + "&page=" + str(page_number) nationalScrape(url, listX) page_number += 1 writeCSV(tempFolder, stateX, listX) for stateX in stateList: nationalCreatePoints(tempFolder, stateX, projectFolder, csvName) del env.workspace env.workspace = projectFolder + '/' + csvName + "_National.gdb" fcList = arcpy.ListFeatureClasses() fcMerge = [] for fc in fcList: fcMerge.append(fc) arcpy.Merge_management(fcMerge, csvName) else: print '\nPlease answer with Yes or No if you would like the results to be geocoded.\n' goNational()
Land_csv = Datafolder + r"\Land.csv" Owner_Address_csv = Datafolder + r"\Owner_Address.csv" Permits_csv = Datafolder + r"\Permits.csv" Sales_csv = Datafolder + r"\Sales.csv" Tax_Areas_csv = Datafolder + r"\Tax_Areas.csv" Tax_Authorities_csv = r"\Tax_Authorities.csv" Values_csv = Datafolder + r"\Values.csv" Parcels_shp = Datafolder + r"\Parcels.shp" County_Boundary_shp = Datafolder + r"\County_Boundary.shp" Municipalities_shp = Datafolder + r"\Municipalities.shp" # Process: Table to Table (Account_Parcels) if arcpy.Exists("Account_Parcels"): arcpy.Delete_management("Account_Parcels") arcpy.TableToGeodatabase_conversion(Account_Parcels_csv, WorkingGDB) arcpy.AddField_management("Account_Parcels", field_name="PARCEL_NO", field_type='Text') arcpy.CalculateField_management(in_table="Account_Parcels", field="PARCEL_NO", expression="!Parcelno!") # Process: Table to Table (Buildings) if arcpy.Exists("Buildings"): arcpy.Delete_management("Buildings") arcpy.TableToGeodatabase_conversion(Buildings_csv, WorkingGDB) # Process: Table to Table (Owner_Address) if arcpy.Exists("Owner_Address"): arcpy.Delete_management("Owner_Address")
FMSS_Assets = os.path.join(new_fgdb, "FMSSExport_Asset") # Process: Delete if arcpy.Exists(new_fgdb): arcpy.Delete_management(new_fgdb, "Workspace") if arcpy.Exists(saved_fgdb): arcpy.Delete_management(saved_fgdb, "Workspace") # Process: Saved published fgdb arcpy.Copy_management(xdrive_fgdb, saved_fgdb, "Workspace") # Process: Create File GDB folder, fgdb = os.path.split(new_fgdb) arcpy.CreateFileGDB_management(folder, fgdb, "CURRENT") # Process: Table To Geodatabase (multiple) arcpy.TableToGeodatabase_conversion(sde_tables, new_fgdb) # Process: Feature Class to Geodatabase (multiple) arcpy.FeatureClassToGeodatabase_conversion(sde_fcs, new_fgdb) # Process: Add Field arcpy.AddField_management(PARKLOTS_py, "Perim_Feet", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") # Process: Calculate Field arcpy.CalculateField_management(PARKLOTS_py, "Perim_Feet", "!shape.length@feet!", "PYTHON_9.3", "") # Process: Add Field (2) arcpy.AddField_management(PARKLOTS_py, "Area_SqFt", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") # Process: Calculate Field (2) arcpy.CalculateField_management(PARKLOTS_py, "Area_SqFt",
# Provide a default value if unspecified pkt_adr_intersect_gminy = "pkt_adr_intersect_gminy" # Process: Intersect arcpy.Intersect_analysis(Input_Features, pkt_adr_intersect_gminy, "ALL", "", "POINT") arcpy.AddField_management(pkt_adr_intersect_gminy, 'nowaUlica', "TEXT", field_length=2048) arcpy.AddField_management(pkt_adr_intersect_gminy, 'nowaMiejscowosc', "TEXT", field_length=2048) arcpy.TableToGeodatabase_conversion(gminyDir, arcpy.env.workspace) print('start') # Replace values in database; updateCursor = arcpy.da.UpdateCursor(pkt_adr_intersect_gminy, cursorAccessFields) for row in updateCursor: if row[0] is None: row[2] = row[1] row[3] = row[4] else: row[2] = row[0] row[3] = row[1] updateCursor.updateRow(row) field_leave = [
def topology_repair( inFile=path_to_shapefile, dissolve_field="", gap_threshold=10000): # threshold is max area of gaps that are considered to be errors # create variables for necessary paths, create gdb, import inFile into feature dataset gdb = os.path.basename(inFile[:-3] + 'gdb') gdbDir= os.path.dirname(inFile) arcpy.CreateFileGDB_management(gdbDir, gdb) arcpy.env.workspace = gdbDir + '/' + gdb feature_ds = arcpy.env.workspace + '/topology_ds' data = arcpy.env.workspace + '/topology_ds/' + os.path.basename(inFile[:-4]) topology = feature_ds + '/Topology' arcpy.CreateFeatureDataset_management(arcpy.env.workspace, "topology_ds", inFile[:-3] + 'prj') arcpy.FeatureClassToGeodatabase_conversion([inFile], "topology_ds") # Create topology, add feature class, define rules arcpy.CreateTopology_management(feature_ds, "Topology") arcpy.AddFeatureClassToTopology_management(topology, data) arcpy.AddRuleToTopology_management(topology, "Must Not Overlap (Area)",data,"","","") arcpy.ValidateTopology_management(topology) # create polygon inFile from errors and delete arcpy.ExportTopologyErrors_management(topology, "", "overlapErrors") arcpy.AddField_management("overlapErrors_poly", dissolve_field, "STRING") o = "o" arcpy.CalculateField_management('overlapErrors_poly', dissolve_field,o) # Create topology, add feature class, define rules arcpy.CreateTopology_management(feature_ds, "Topology") arcpy.AddFeatureClassToTopology_management(topology, data) arcpy.AddRuleToTopology_management(topology, "Must Not Have Gaps (Area)",data,"","","") arcpy.ValidateTopology_management(topology) # create polygon inFile from errors and merge with original data arcpy.ExportTopologyErrors_management(topology, "", "gapErrors") arcpy.FeatureToPolygon_management("gapErrors_line","topo_errors_gaps") arcpy.SelectLayerByAttribute_management ("topo_errors_gaps", "NEW_SELECTION", '"Shape_Area" < ' + str(gap_threshold)) arcpy.AddField_management("topo_errors_gaps", dissolve_field, "STRING") g = "g" arcpy.CalculateField_management('topo_errors_gaps', dissolve_field,g ) arcpy.SelectLayerByAttribute_management ("topo_errors_gaps", "SWITCH_SELECTION") arcpy.DeleteRows_management("topo_errors_gaps") arcpy.Merge_management(["overlapErrors_poly", "topo_errors_gaps" ,inFile],"topomerged") # Get neighbor table and export to gdb arcpy.PolygonNeighbors_analysis('topomerged', 'topo_errors',['OBJECTID', dissolve_field]) # doesn't always find neighbors on all sides of polygon arcpy.TableToGeodatabase_conversion('topo_errors',arcpy.env.workspace) #table to array and array to dataframe nbr_field = 'nbr_' + dissolve_field arr = arcpy.da.FeatureClassToNumPyArray(("topo_errors"), ("src_OBJECTID", nbr_field, "LENGTH")) index = [str(i) for i in range(1, len(arr)+1)] df = pd.DataFrame(arr, index=index) df = df.groupby(['src_OBJECTID','nbr_TYPE'],as_index = False)['LENGTH'].sum() #sum in case several sides of polygon have same neighbor #select rows from df and export to csv and to gdb idx = df.groupby(['src_OBJECTID'])['LENGTH'].transform(max) == df['LENGTH'] df_select = df [idx] df_select.to_csv(gdbDir+'/joinme.csv', index=False) arcpy.TableToTable_conversion(gdbDir+'/joinme.csv', arcpy.env.workspace, "joinme") # Merge error polygons, join field, delete overlaps from infile, assign type to error polygons, merge all and dissolve arcpy.JoinField_management('topomerged', 'OBJECTID', 'joinme', 'src_OBJECTID', 'nbr_TYPE') arcpy.FeatureClassToFeatureClass_conversion('topomerged', "", 'topo_errors_join') arcpy.SelectLayerByAttribute_management("topo_errors_join", "NEW_SELECTION", "TYPE = 'o'") arcpy.SelectLayerByAttribute_management("topo_errors_join", "ADD_TO_SELECTION", "TYPE = 'g'") arcpy.SelectLayerByAttribute_management ("topo_errors_join", "SWITCH_SELECTION") arcpy.DeleteRows_management("topo_errors_join") #leave only error polygons arcpy.AlterField_management('topo_errors_join', 'TYPE', 'orig_TYPE','orig_TYPE') arcpy.AlterField_management('topo_errors_join', 'nbr_TYPE', 'TYPE','TYPE') arcpy.Erase_analysis(inFile,'overlapErrors_poly','infile_overlaps_erased') arcpy.Merge_management(["topo_errors_join","infile_overlaps_erased"],"merged_neighbors") arcpy.Dissolve_management('merged_neighbors', 'dissolved_neighbors', 'TYPE')
tables = arcpy.ListTables() print(' -- Tables: ', tables) print(' -- Process complete. Check for errors and move to next cell.') print(' ') #----------------------------------------------------------------------------------------- # 5.0 - Execute TableToGeodatabase #----------------------------------------------------------------------------------------- print('Step 5.0 - Execute TableToGeodatabase: ') print(' -- Executing...') try: print(' -- Importing tables to gdb: ' + outLocation) arcpy.TableToGeodatabase_conversion(csv_name, outLocation) except: print(arcpy.GetMessages()) print(' -- Process complete. Check for errors and move to next cell.') print(' ') #----------------------------------------------------------------------------------------- # 6.0 - Convert Table to Feature Class #----------------------------------------------------------------------------------------- print('Step 6.0 - Convert Table to Feature Class...') print(' -- Executing...') arcpy.env.workspace = working_dir arcpy.env.overwriteOutput = True
def import_vicmap_fgdb_data(vicmap_version): logging.info('local variables') vm = gis.VICMAP(vicmap_version) imported_fcs = [] imported_tables = [] logging.info('exclusion list:') exclude_list = [ # VMELEV 'EL_CONTOUR_1TO5M', 'EL_GRND_SURFACE_POINT_1TO5M', # VMPROP 'ANNOTATION_TEXT', 'CAD_AREA_BDY', 'EASEMENT', 'CENTROID', 'PARCEL_CAD_AREA_BDY', 'PROPERTY_CAD_AREA_BDY', ] for exclude in exclude_list: logging.info(exclude) logging.info('starting import') for root, gdb_names, files in arcpy.da.Walk(vm.path, datatype='Container'): for gdb_name in gdb_names: if gdb_name.lower().endswith('gdb'): logging.info(gdb_name) gdb_folder = os.path.join(vm.path, gdb_name) arcpy.env.workspace = gdb_folder fcs = [] fc_names = arcpy.ListFeatureClasses() for fc in fc_names: if fc.upper() in exclude_list: continue if arcpy.Exists(os.path.join(vm.path, vm.sde, fc)): logging.info('exists: {}'.format(fc)) continue logging.info('loading feature class: ' + fc) fcs.append(os.path.join(gdb_folder, fc)) if fcs: arcpy.FeatureClassToGeodatabase_conversion(Input_Features=fcs, Output_Geodatabase=os.path.join(vm.path, vm.sde)) imported_fcs.extend(fcs) tables = [] table_names = arcpy.ListTables() for table in table_names: if table.upper() in exclude_list: continue if arcpy.Exists(os.path.join(vm.path, vm.sde, table)): logging.info('exists: {}'.format(table)) continue logging.info('loading table: ' + table) tables.append(os.path.join(gdb_folder, table)) if tables: arcpy.TableToGeodatabase_conversion(Input_Table=tables, Output_Geodatabase=os.path.join(vm.path, vm.sde)) imported_tables.extend(tables) return [imported_fcs, imported_tables]
for tiff in tiffs: tiffSplit = tiff.split("_") year = tiffSplit[1] month = tiffSplit[2] #Extract Values to Points *** Change GPS point here*** arcpy.gp.ExtractValuesToPoints_sa( gpsPoints + "GPS_final.shp", fs_rasters + "fc_" + year + "_" + month, out_extract + "out_" + year + "_" + month + ".shp", "NONE", "VALUE_ONLY") print 'finished values to Table run: %s\n\n' % (datetime.datetime.now() - start) #Copy extract by points table to Geodatabase arcpy.TableToGeodatabase_conversion( Input_Table=out_extract + "out_" + year + "_" + month, Output_Geodatabase='C:/workspace/chirps/processing/data.gdb/') century_year = (int(year) - 1900) * 12 + int(month) arcpy.AddField_management(dataGDB + "out_" + year + "_" + month, "CenturyMonth", "FLOAT", "", "", "7", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(in_table=dataGDB + "out_" + year + "_" + month, field="CenturyMonth", expression=century_year, expression_type="VB", code_block="") #Table to CSV arcpy.TableToTable_conversion(dataGDB + "out_" + year + "_" + month, out_csv, "csv" + year + "_" + month + ".csv")
arcpy.env.XYTolerance = '0.000000001798644 Degrees' arcpy.env.MResolution = 0.0001 arcpy.env.MTolerance = 0.0002 # set the M tolerance to the cansys tolerance, tolerance = resx2 arcpy.env.overwriteOutput = True incrnd = ws + "\\" + tempmdb + "\\CRND" insrnd = ws + "\\" + tempmdb + "\\SRND" qclean = "NETWORK_DIRECTION in ( 'EB' , 'NB' ) AND ROUTE NOT LIKE '999%' AND UNIQUE_NUMBER NOT LIKE '9'" arcpy.MakeFeatureLayer_management(incrnd, "CRND", qclean) arcpy.MakeFeatureLayer_management(insrnd, "SRND", qclean) arcpy.FeatureClassToGeodatabase_conversion("CRND", ws + "\\" + tempgdb) #10 sec arcpy.FeatureClassToGeodatabase_conversion("SRND", ws + "\\" + tempgdb) #9 sec arcpy.MakeTableView_management( r"Database Connections\atlasprod.odc\KDOT.MV_map_extract", "MAP_EXTRACT", "DIRECTION <=2") arcpy.TableToGeodatabase_conversion("MAP_EXTRACT", ws + "\\" + tempgdb) del mxd mxd = arcpy.mapping.MapDocument( r"\\GISDATA\ArcGIS\GISDATA\MXD\NewGISNetworkSeed.mxd") arcpy.MakeFeatureLayer_management(ws + "\\" + tempgdb + "\\CRND", "CRND") arcpy.MakeFeatureLayer_management(ws + "\\" + tempgdb + "\\SRND", "SRND") arcpy.MakeTableView_management(ws + "\\" + tempgdb + "\\MAP_EXTRACT", "MAP_EXTRACT", "DIRECTION <=2") arcpy.AddField_management(ws + "\\" + tempgdb + "/MAP_EXTRACT", "SRND", "TEXT", "#", "#", "24") arcpy.CalculateField_management(ws + "\\" + tempgdb + "/MAP_EXTRACT", "SRND", """Mid([NQR_DESCRIPTION],4,16)""", "VB", "#") arcpy.AddField_management(ws + "\\" + tempgdb + "/MAP_EXTRACT", "CRND", "TEXT", "#", "#", "24") arcpy.CalculateField_management(ws + "\\" + tempgdb + "/MAP_EXTRACT", "CRND", """[NQR_DESCRIPTION]""", "VB", "#")
gdb = outLocation + g + ".gdb" arcpy.CopyFeatures_management(inFeatures, gdb + "/" + inFeatures[:-4]) arcpy.CopyFeatures_management(inFeatures2, gdb + "/" + inFeatures2[:-4]) arcpy.CopyFeatures_management(inFeatures4, gdb + "/" + inFeatures4[:-4]) arcpy.CopyFeatures_management(inFeatures5, gdb + "/" + inFeatures5[:-4]) arcpy.CopyFeatures_management(inFeatures6, gdb + "/" + inFeatures6[:-4]) arcpy.CopyFeatures_management(inFeatures7, gdb + "/" + inFeatures7[:-4]) arcpy.CopyFeatures_management(inFeatures8, gdb + "/" + inFeatures8[:-4]) arcpy.TableToGeodatabase_conversion([joinTable, joinTable2], gdb) if joinTable3 == "": arcpy.CopyFeatures_management(inFeatures3, gdb + "/" + inFeatures3[:-4]) else: arcpy.CopyFeatures_management(inFeatures3, gdb + "/" + inFeatures3[:-4]) arcpy.TableToGeodatabase_conversion(joinTable3, gdb) print("przekopiowalem pliki do geobazy w: " + g) inFeatures = "" inFeatures2 = "" inFeatures3 = "" inFeatures4 = "" inFeatures5 = "" inFeatures6 = "" inFeatures7 = ""
for i in range(0, len(tableList)): try: arcpy.Delete_management("tblPart" + str(i)) except: pass print "Table Created for Raster: " + os.sep + inValueRaster print "joining tables" env.workspace = outFolder tList = arcpy.ListTables() print str(tList) + " = tables in outfolder" gdbName = zoneName + "masterTableGDB" masterTableGDB = arcpy.CreateFileGDB_management(outFolder, gdbName, "CURRENT") print str(masterTableGDB) + "= masterTableGDB" arcpy.TableToGeodatabase_conversion(tList, masterTableGDB) env.workspace = outFolder + os.sep + "masterTableGDB.gdb" tList = arcpy.ListTables() tbl = tList[0] masterTableGDB = str(masterTableGDB) + os.sep + "masterTableGDB" arcpy.Copy_management(tbl, masterTableGDB) for t in tList: varName = t[:-4] varNameMean = varName[:3] + "_MEAN" print varName + " = varName" arcpy.JoinField_management(masterTableGDB, "TARGET_FID", t, "TARGET_FID") arcpy.AddField_management(masterTableGDB, varNameMean, "FLOAT", "20", "4", "", varNameMean, "NULLABLE", "NON_REQUIRED", "") # Process: Add Field