def CopyDomainsBetweenTables(inputTable, outputTable): inGDB = os.path.split(inputTable)[0] outGDB = os.path.split(outputTable)[0] arcpy.env.overwriteOutput = True dscOutWorkspace = arcpy.Describe(outGDB) domainList = [] domainDict = dict() fieldList = arcpy.ListFields(inputTable) for field in fieldList: if field.domain: print("{0} has domain {1}".format(field.name, field.domain)) if not (field.domain in dscOutWorkspace.domains): arcpy.DomainToTable_management(inGDB, field.domain, "IN_MEMORY/DomainTab", "Code", "Description") arcpy.TableToDomain_management("IN_MEMORY/DomainTab", "Code", "Description", outGDB, field.domain) arcpy.AddMessage("Added " + field.domain + " to " + outGDB) domainDict[field.name] = field.domain domainList += [field.domain] fieldList = arcpy.ListFields(outputTable) for field in fieldList: if not field.domain and domainDict.has_key(field.name): arcpy.AssignDomainToField_management(outputTable, field.name, domainDict[field.name]) arcpy.AddMessage("Assigned " + field.domain + " to " + outputTable) arcpy.SetParameterAsText(2, outputTable)
def export_all_domains(geodatabase, workspace=None): """Output all the domains in a geodatabase to tables in a workspace. :param geodatabase {String}: Path or reference to a geodatabase. :param output_folder {String} optional path to output folder. If not supplied defaults to gdb """ try: if not workspace: workspace = geodatabase domains = arcpy.da.ListDomains(geodatabase) for domain in domains: dname = arcpy.ValidateTableName(domain.name + '_domain', workspace) output = os.path.join(workspace, dname) output_msg('Exporting {0} domain to {1}'.format( domain.name, dname)) arcpy.DomainToTable_management(geodatabase, domain.name, output, "codedValues", 'description') except Exception as e: output_msg(str(e.args[0])) output_msg(arcpy.GetMessages()) finally: output_msg("Completed")
def initializeRulesByMilitaryFeatures(self, featureClass): # Military Feature use several different possible fields to store this Rule ID desc = arcpy.Describe(featureClass) CODE_FIELD_NAME = "code" DESCRIPTION_FIELD_NAME = "description" ruleFieldName = None ruleDomainName = None for field in desc.Fields: if (field.name in DictionaryConstants.RuleFieldsList): if (field.domain is not None and field.domain != ""): # Note Bene: only works with FGDBs (assumes MilFeature only stored in these) dataPath = desc.path gdbPath = dataPath.split(".gdb")[0] gdbPath += ".gdb" ruleFieldName = field.name ruleDomainName = field.domain arcpy.DomainToTable_management( gdbPath, field.domain, "in_memory/" + ruleDomainName, CODE_FIELD_NAME, DESCRIPTION_FIELD_NAME) break # map both ways for performance/simplicty of use ruleID2Name = self.getRuleID2NameDictionary() name2RuleID = self.getName2RuleIDDictionary() symbolCount = 0 if (ruleFieldName is None) or (ruleDomainName is None): arcpy.AddError("Layer RuleId not found, can't continue") else: print "Symbol RuleId found & exporting: " + ruleFieldName domainRows = arcpy.SearchCursor("in_memory/" + ruleDomainName) for domainRow in domainRows: ruleid = domainRow.getValue(CODE_FIELD_NAME) symbolname = domainRow.getValue(DESCRIPTION_FIELD_NAME) if self.endsInPAA(symbolname): symbolname = symbolname[0:-6] symbolCount = symbolCount + 1 print str(ruleid) + " --> " + symbolname ruleID2Name[ruleid] = symbolname name2RuleID[symbolname] = ruleid if symbolCount == 0: arcpy.AddError("No Layer RepRules found, can't continue") ruleFieldName = None elif symbolCount < 50: arcpy.AddWarning("Only " + str(symbolCount) + " RepRules found, may not work as expected") return ruleFieldName
def export_domains(domains): for domain in domains: arcpy.AddMessage('Exporting %s CV to table in %s' % (domain.name, gdb)) table = os.path.join(gdb, domain.name) arcpy.DomainToTable_management(gdb, domain.name, table, 'field', 'descript', '#') if xls: os.chdir(gdb) os.chdir('..') xlsfile = '%s_%s.xls' % (os.path.join( os.path.basename(gdb)), domain.name) arcpy.AddMessage('Exporting %s CV to table in %s' % (domain.name, xlsfile)) arcpy.TableToExcel_conversion(table, xlsfile)
def create_domain_table(self, domain): domain_name = slugify(domain.name, separator='_', lowercase=False) domain_table = "{}_lut".format(domain_name) domain_field = "Code" domain_field_desc = "Description" print(" {}".format(domain_table)) if not arcpy.Exists(domain_table): arcpy.DomainToTable_management( self.workspace, domain.name, domain_table, domain_field, domain_field_desc) # create index self.create_index(domain_table, domain_field) self.split_schemas(domain_table, "lookup_tables")
def DomainToTableIamuw(DomainLocation, NameFilter, TableDatabase): ''' This function takes a database that contains ESRI domains (string) that the user wants to export to tables. A filter to query out some of the domains if necessary (string) and finally a secondary database where the new tables will be created (string). ''' arcpy.env.workspace = TableDatabase arcpy.env.overwriteOutput = True Description = arcpy.Describe(DomainLocation) Domains = Description.domains for Domain in Domains: print Domain if NameFilter in Domain: Table = os.path.join(TableDatabase, Domain) arcpy.DomainToTable_management(DomainLocation, Domain, Table, 'Code', 'Description')
def create_domain_table(self, domain): domain_name = domain.name.replace(" ", "") domain_table = "%s_lut" % domain_name domain_field = "Code" domain_field_desc = "Description" print " %s" % domain_table if not arcpy.Exists(domain_table): arcpy.DomainToTable_management(self.workspace, domain.name, domain_table, domain_field, domain_field_desc) # create index self.create_index(domain_table, domain_field) self.split_schemas(domain_table, "lookup_tables")
def __init__(self): global bike_lanes_cv self.items = [] self.bike_lanes_dict = {} arcpy.DomainToTable_management( r'X:\Trans\Bicycle and Pedestrian\Data\BikeFacilities\2020_GDB_Update\OSM_Sockeye.sde', 'BikeLanes2', 'in_memory/bike_lanes_cv', 'codeField', 'descriptionField') with arcpy.da.SearchCursor( 'in_memory/bike_lanes_cv', ['codeField', 'descriptionField']) as cursor: for row in cursor: self.bike_lanes_dict[row[1]] = row[0] self.items.append(row[1]) #arcpy.Delete_management("in_memory/bike_lanes_cv") bike_lanes_cv = self.bike_lanes_dict['Yes'] #self.cvd_dict = self.getCVDDict() #self.items = ["item1", "item2"] self.editable = True self.enabled = True self.dropdownWidth = 'WWW' self.width = 'WWW' self.value = "Yes"
def create_domain_table(self, domain): domain_name = domain.name.replace(" ", "") logging.debug("create_domain_table: {} ".format(domain_name)) domain_table = "{}{}".format(self.lookup_prefix, domain_name.lower()) domain_field = "Code" domain_field_desc = "Description" logging.debug(" %s" % domain_table) if not arcpy.Exists(domain_table): arcpy.DomainToTable_management(self.workspace, domain.name, domain_table, domain_field, domain_field_desc) # create index dom = { "feature": domain_table, "type": "table", "schema": self.lookup_tables_schema } self.domain_tables.append(dom) self.create_index(domain_table, domain_field, self.lookup_tables_schema)
import os import arcpy from arcpy.sa import * arcpy.env.overwriteOutput = True geodatabase_name = r"Vancouver.gdb" geodatabase_location = r"G:\CART3032\projects\Vancouver" geodatabase = os.path.join(geodatabase_location, geodatabase_name) target_location = r"C:\Temp" code_field = "Key" value_field = "Value" domains = [ "road_class_cl", "building_function_cl", ] # domains = arcpy.Describe(geodatabase).domains for domain in domains: dbf = os.path.join(target_location, domain + ".dbf") arcpy.DomainToTable_management(geodatabase, str(domain), dbf, code_field, value_field) with arcpy.da.UpdateCursor(dbf, [value_field]) as cursor: for row in cursor: row[0] = row[0].split(": ")[1].split(" / ")[0] cursor.updateRow(row)
import os, arcpy # Set workspace environment to geodatabase arcpy.env.workspace = r"C:\Users\jamatney\AppData\Roaming\Esri\Desktop10.2\ArcCatalog\rtca user connected to rtca_new database.sde" arcpy.overwriteOutput = True gdb = r"C:\Users\jamatney\AppData\Roaming\ESRI\Desktop10.4\ArcCatalog\Connection to CASCADES.cnr.ncsu.edu.sde" gdb_domains = r"C:\Users\jamatney\Desktop\Domains\domains.gdb" desc = arcpy.Describe(gdb) domains = desc.domains for domain in domains: print 'Exporting %s CV to table in %s' % (domain, gdb) out_table = os.path.join(gdb_domains, domain) arcpy.DomainToTable_management(gdb, domain, out_table, 'field','description', '#')
def createTables(surveyGDB, outWorkspace, prefix): '''Creates the doamins, tables and relationships of the survey in the target workspace''' arcpy.AddMessage('\t-Creating Tables') arcpy.env.workspace = surveyGDB allTables = getSurveyTables(surveyGDB) dscW = arcpy.Describe(arcpy.env.workspace) #migrate the domains arcpy.AddMessage('\t\t-Creating Domains') for domainName in dscW.domains: if domainName[0:3] == 'cvd': arcpy.AddMessage('\t\t\t-'.format(domainName)) tempTable = 'in_memory\{0}'.format(domainName) domainTable = arcpy.DomainToTable_management(surveyGDB, domainName, tempTable,'CODE', 'DESC') newDomain = arcpy.TableToDomain_management(tempTable, 'CODE', 'DESC', outWorkspace, domainName, update_option='REPLACE') arcpy.Delete_management(tempTable) arcpy.AddMessage("\t\t-Creating Feature Classes & Tables") for table in allTables: dsc = arcpy.Describe(table) newTableName = "{0}_{1}".format(prefix, table) templateTable = template=os.path.join(surveyGDB, table) if dsc.datatype == u'FeatureClass': newTable = arcpy.CreateFeatureclass_management(outWorkspace, newTableName, "POINT", template=templateTable, spatial_reference=dsc.spatialReference) else: newTable = arcpy.CreateTable_management(outWorkspace, newTableName, template=templateTable) arcpy.AddMessage("\t\t\t-Created {0}".format(newTableName)) #Attach domains to fields tableFields = arcpy.ListFields(table) for field in tableFields: if field.domain != '': arcpy.AssignDomainToField_management(newTable, field.name, field.domain) if dscW.workspaceType == "RemoteDatabase": arcpy.RegisterAsVersioned_management(newTable) arcpy.AddMessage('\t\t-Creating Relationships') #Reconnect Relationship classes, checking for attachments CARDINALITIES = { 'OneToOne': "ONE_TO_ONE", 'OneToMany': "ONE_TO_MANY", 'ManyToMany': "MANY_TO_MANY" } for child in [(c.name, c.datatype) for c in dscW.children if c.datatype == u'RelationshipClass']: dscRC = arcpy.Describe(child[0]) RCOriginTable = dscRC.originClassNames[0] RCDestTable = dscRC.destinationClassNames[0] newOriginTable = "{0}_{1}".format(prefix, RCOriginTable) newOriginPath = os.path.join(outWorkspace, newOriginTable) if dscRC.isAttachmentRelationship: #Simple case - attachments have a dedicated tool arcpy.EnableAttachments_management(newOriginPath) else: newDestTable = "{0}_{1}".format(prefix, RCDestTable) newDestPath = os.path.join(outWorkspace, newDestTable) newRC = os.path.join(outWorkspace, "{0}_{1}".format(prefix, child[0])) relationshipType = "COMPOSITE" if dscRC.isComposite else "SIMPLE" fwd_label = dscRC.forwardPathLabel if dscRC.forwardPathLabel != '' else 'Repeat' bck_label = dscRC.backwardPathLabel if dscRC.backwardPathLabel != '' else 'MainForm' msg_dir = dscRC.notification.upper() cardinality = CARDINALITIES[dscRC.cardinality] attributed = "ATTRIBUTED" if dscRC.isAttributed else "NONE" originclassKeys = dscRC.originClassKeys originclassKeys_dict = {} for key in originclassKeys: originclassKeys_dict[key[1]] = key[0] originPrimaryKey = originclassKeys_dict[u'OriginPrimary'] originForiegnKey = originclassKeys_dict[u'OriginForeign'] arcpy.CreateRelationshipClass_management(newOriginPath, newDestPath, newRC, relationshipType, fwd_label, bck_label, msg_dir, cardinality, attributed, originPrimaryKey, originForiegnKey)
# encoding=utf8 import json import os import arcpy import pandas as pd arcpy.env.overwriteOutput = True gdb = r'D:\APPS\SURVEY\BDG_YACMIN\GPT_YM_YACIM_1.gdb' path = r'D:\APPS\SURVEY\BDG_YACMIN\tb' lDom = [x.name for x in arcpy.da.ListDomains(gdb)] for x in lDom: print x tbtemp = arcpy.DomainToTable_management(gdb, x, os.path.join(gdb, "tb_%s" % x), "Code", "Desc") with arcpy.da.SearchCursor(tbtemp, ["Code", "Desc"]) as cursor: for i in cursor: # data = arcpy.da.TableToNumPyArray(tbtemp, ["Code", "Desc"]) # print data # df = pd.DataFrame(data) # print df with open(path + "{}.json".format(x), 'wb') as outfile: json.dump(df, outfile)
#Start exporting Domains to tables logger.log( 10, '4 ; Processing domains in ' + desc.DataType + ' ' + desc.CatalogPath + ' ' + ' (' + desc.ShapeType + ' type)') cursor.execute('SELECT * FROM Domains') rows = cursor.fetchall() for fld in desc.Fields: for row in rows: if fld.domain != '' and fld.domain == row[ 0]: arcpy.DomainToTable_management( database, fld.domain, gdb_target + '\\' + fld.domain, "Code", "Description") logger.log( 10, '4 ; Exported ' + fld.domain + ' domain table to ' + gdb_target + '\\' + fld.domain) logger.log( 10, '4 ; Finished processing domains for Feature class ' + database + '\\' + fds + '\\' + fc) # inserting columns logger.log(
def writeMessageFile(): global DEBUG_GEOMETRY_CONVERSION, appendFile, foundEmptySIDC, FORCE_UNIQUE_IDs try: arcpy.AddMessage("Starting: Write/Append Message File") # Get input feature class inputFC = arcpy.GetParameter(0) if (inputFC == "") or (inputFC is None): inputFC = os.path.join( MilitaryUtilities.dataPath, r"/test_inputs.gdb/FriendlyOperations/FriendlyUnits") desc = arcpy.Describe(inputFC) if desc is None: arcpy.AddError("Bad Input Feature Class") return shapeType = desc.shapeType # Get output filename outputFile = arcpy.GetParameterAsText(1) # Get standard standard = arcpy.GetParameterAsText(2) # Message Type Field messageTypeField = arcpy.GetParameterAsText(3) # Sort Order orderBy = arcpy.GetParameterAsText(4) # Disable Geo Transformation and use default SIDC disableGeoTransform = arcpy.GetParameterAsText(5) if not ((disableGeoTransform == "") or (disableGeoTransform is None)): DEBUG_GEOMETRY_CONVERSION = (disableGeoTransform.upper() == "TRUE") arcpy.AddMessage("Running with Parameters:") arcpy.AddMessage("0 - Input FC: " + str(inputFC)) arcpy.AddMessage("1 - outputXMLFile: " + str(outputFile)) arcpy.AddMessage("2 - symbology standard: " + str(standard)) arcpy.AddMessage("3 - MessageTypeField: " + messageTypeField) arcpy.AddMessage("4 - orderBy: " + orderBy) arcpy.AddMessage("5 - disableGeoTransform: " + disableGeoTransform) # initialize the standard MilitaryUtilities.getGeometryConverterStandard(standard) if DEBUG_GEOMETRY_CONVERSION: arcpy.AddWarning( "Running in Debug Geo-Transformation Mode, symbol will use default/unknown SIDC for shape" ) if not ((messageTypeField == "") or (messageTypeField is None)): # make sure the messageTypeField exists in the input if messageTypeField in [field.name for field in desc.Fields]: MilitaryUtilities.MessageTypeField = messageTypeField else: arcpy.AddWarning("MessageTypeField does not exist in input: " + messageTypeField + " , using default") # Check Output Filename & see handle case if we are appending if (outputFile == "") or (outputFile is None): # For a standalone test (debug) if no output filename provided if DEBUG_GEOMETRY_CONVERSION: defaultOutputName = "Mil2525CMessages-NoTransform.xml" else: defaultOutputName = "Mil2525CMessages.xml" outputFile = os.path.join(os.path.dirname(__file__), defaultOutputName) messageFile = open(outputFile, "w") arcpy.AddWarning("No Output set, using default: " + str(outputFile)) else: arcpy.AddMessage("Append File set to " + str(appendFile)) if (not appendFile): messageFile = open(outputFile, "w") elif (not os.path.isfile(outputFile)): arcpy.AddWarning( "Can't Append: Output File does not exist, creating new file" ) messageFile = open(outputFile, "w") else: arcpy.AddMessage("Appending Existing File...") # Appending the file is a bit more complicated because we have to remove the # "</messages>" from the end of the original file therefore it can't just be # opened as an append "a+"-we have to create a temp file, read the original file in, # except for the line "</messages>", and then write back out fileToAppend = open(outputFile, "r") # Workaround/Note: didn't work in ArcCatalog unless I opened temp file this way temporaryFile = tempfile.NamedTemporaryFile(mode="w", delete=False) # Copy the file line by line, but don't include last end tag ex. </messages> finalTag = "</%s>" % MilitaryUtilities.getMessageRootTag() finalTagFound = False while True: line = fileToAppend.readline() if line: if not finalTag in line: # ex. "</messages>" temporaryFile.write(line) else: finalTagFound = True else: break if (not finalTagFound): arcpy.AddError( "XML Append File will be corrupt: Could not find Tag: " + finalTag) # now write those lines back fileToAppend.close() temporaryFile.close() messageFile = open(outputFile, "w") temporaryFile = open(temporaryFile.name, "r") while True: line = temporaryFile.readline() if line: messageFile.write(line) else: break temporaryFile.close() if (messageFile is None): arcpy.AddError("Output file can't be created, exiting") return ##################Setup for export############################ # We need to set overwriteOutput=true or the tools below may fail previousOverwriteOutputSetting = arcpy.env.overwriteOutput arcpy.env.overwriteOutput = True # Densify if this is a polygon FC if (shapeType == "Polygon"): try: densifiedFC = "in_memory/DensifiedFC" arcpy.CopyFeatures_management(inputFC, densifiedFC) arcpy.Densify_edit(densifiedFC, "ANGLE", "", "", 10) inputFC = densifiedFC except: arcpy.AddWarning( "Could not densify polygons, skipping. Densify_edit tool failed - is Desktop Standard License available?" ) # Get fields and coded domains CODE_FIELD_NAME = "code" DESCRIPTION_FIELD_NAME = "description" fieldNameList = [] fieldNameToDomainName = {} for field in desc.Fields: if not (field.name in DictionaryConstants.MILFEATURES_FIELD_EXCLUDE_LIST): fieldNameList.append(field.name) # Get domain if any if (field.domain is not None and field.domain != ""): fieldNameToDomainName[field.name] = field.domain dataPath = desc.path gdbPath = dataPath.split(".gdb")[0] gdbPath += ".gdb" arcpy.DomainToTable_management(gdbPath, field.domain, "in_memory/" + field.domain, CODE_FIELD_NAME, DESCRIPTION_FIELD_NAME) # print fieldNameList # restore this setting (set above) arcpy.env.overwriteOutput = previousOverwriteOutputSetting # Projected or geographic? xname = "lon" yname = "lat" isProjected = desc.spatialReference.type == "Projected" if (isProjected): xname = "x" yname = "y" wkid = desc.spatialReference.factoryCode ################Begin Export ########################## # Open a search cursor (if possible) try: rows = arcpy.SearchCursor(inputFC, "", "", "", orderBy) except: arcpy.AddError("Could not open Feature Class " + str(inputFC)) if (not ((orderBy == "") and not (orderBy is None))): arcpy.AddError("OrderBy Search Option: " + orderBy) raise Exception("Bad Feature Class Input") # Dictionary to map unique designation to ID unitDesignationToId = dict() featureFields = desc.fields ###################### Write XML file ######################### if not appendFile: # Ex: Next line writes: messageFile.write("<geomessages>\n") messageFile.write("<%s>\n" % MilitaryUtilities.getMessageRootTag()) rowCount = 0 # Iterate through the rows in the cursor for row in rows: shape = row.shape.getPart(0) arcpy.AddMessage("Processing row: " + str(rowCount)) ############################################## # Map Unique Names to same Unique IDs # IMPORTANT: this section tries to keep Unique Designations mapped to the # same Message Unique ID (so they will move in Message Processor), so... # WARNING: if you have repeated Unique Designations, # they are going to get mapped to the same Unique ID uniqueId = "{%s}" % str(uuid.uuid4()) uniqueDesignation = str( rowCount) # fallback value in case field does not exist try: uniqueDesignation = row.getValue( MilitaryUtilities.UniqueDesignationField) if ((uniqueDesignation is None) or (uniqueDesignation == "")): arcpy.AddWarning("Unique Designation is Empty") elif (DEBUG_GEOMETRY_CONVERSION or FORCE_UNIQUE_IDs): pass else: # Otherwise, see if we have seen this Designation before if (uniqueDesignation in unitDesignationToId): arcpy.AddMessage( "Creating update message for repeated Unique Designation: " + uniqueDesignation) uniqueId = unitDesignationToId[uniqueDesignation] else: unitDesignationToId[uniqueDesignation] = uniqueId except: arcpy.AddWarning( "Could not find Unique Designation field in row: " + str(rowCount)) ############################################## # work with "sidc" or "sic" try: SymbolIdCodeVal = row.getValue( MilitaryUtilities.SidcFieldChoice1) # "sic" except: try: SymbolIdCodeVal = row.getValue( MilitaryUtilities.SidcFieldChoice2) # "sidc" except: SymbolIdCodeVal = None # Note/Important: attributes need to be set in converter so needs declared before geometrytoControlPoints attributes = {} conversionNotes = None attributes[ DictionaryConstants.Tag_Wkid] = wkid # needed by conversion if (SymbolIdCodeVal is None) or (SymbolIdCodeVal == ""): SymbolIdCodeVal = DictionaryConstants.getDefaultSidcForShapeType( shapeType) if not (DEBUG_GEOMETRY_CONVERSION): foundEmptySIDC = True msg = "SIDC is not set, using default: " + SymbolIdCodeVal arcpy.AddWarning(msg) # TODO: we may need to add an option to Disable the geometry conversion # *but* not to change the SIDC to the default one, if you don't want the SIDC to change # when "Disable Geometry Conversion" is checked, comment/uncomment thses lines to # set this to false/disable this behavior: # elif False : elif DEBUG_GEOMETRY_CONVERSION: print "Using Debug SIDC" conversionNotes = "Original SIDC: " + SymbolIdCodeVal uniqueDesignation = SymbolIdCodeVal # use this label for debugging SymbolIdCodeVal = DictionaryConstants.getDefaultSidcForShapeType( shapeType) controlPointsString = MilitaryUtilities.parseGeometryToControlPoints( shape) requiresConversion = MilitaryUtilities.geoConverter.requiresConversion( SymbolIdCodeVal) if requiresConversion and not DEBUG_GEOMETRY_CONVERSION: msg = "SIC: " + SymbolIdCodeVal + " requires conversion/translation" print msg arcpy.AddMessage(msg) transformedPoints, conversionNotes = \ MilitaryUtilities.geoConverter.geometrytoControlPoints(SymbolIdCodeVal, controlPointsString, attributes) if (conversionNotes == DictionaryConstants.CONVERSION_IGNORE_SECOND_LINE): continue elif (transformedPoints is None): arcpy.AddWarning("Conversion FAILED for SIC: " + SymbolIdCodeVal + \ ", Notes: " + conversionNotes + " (using original points)") else: controlPointsString = transformedPoints # Write Output Message # Ex: Next line writes: ex. "\t<geomessage v=\"1.0\">\n" messageFile.write("\t<%s v=\"%s\">\n" % (MilitaryUtilities.getMessageTag(), \ MilitaryUtilities.getMessageVersion())) messageFile.write("\t\t<sic>%s</sic>\n" % SymbolIdCodeVal) # Try to get a message type if the field exists try: messageTypeVal = row.getValue( MilitaryUtilities.MessageTypeField) messageFile.write("\t\t<_type>%s</_type>\n" % messageTypeVal) except: # if not default to position_report messageFile.write("\t\t<_type>%s</_type>\n" % DictionaryConstants.DefaultMessageType) ##TODO: see if other actions are valid besides just "update" messageFile.write( "\t\t<_action>%s</_action>\n" % DictionaryConstants.DefaultMessageAction) # = update messageFile.write("\t\t<_id>%s</_id>\n" % uniqueId) messageFile.write("\t\t<_control_points>%s</_control_points>\n" % controlPointsString) if not ((conversionNotes is None) or (conversionNotes == "")): messageFile.write( "\t\t<ConversionNotes>%s</ConversionNotes>\n" % conversionNotes) # Note: written with attributes below: messageFile.write("\t\t<_wkid>%i</_wkid>\n" % wkid) if not ((uniqueDesignation is None) or (uniqueDesignation == "")): messageFile.write("\t\t<%s>%s</%s>\n" % (DictionaryConstants.Tag_UniqueDesignation, \ uniqueDesignation, DictionaryConstants.Tag_UniqueDesignation)) # Check on Military Geometries for Lines/Areas if (shapeType is "Point"): messageFile.write("\t\t<altitude_depth>%d</altitude_depth>\n" % shape.Z) rowCount = rowCount + 1 messageFile.write("\t\t<MessageCount>%s</MessageCount>\n" % str(rowCount)) for key in attributes: attrValAsString = str(attributes[key]) messageFile.write("\t\t<" + key + ">" + attrValAsString + "</" + key + ">\n") ###################Common Fields/Attributes##################### # Write out remaining table fields as Tag attributes for field in fieldNameList: try: # But don't repeat existing tags we've created if field in DictionaryConstants.MESSAGES_TAG_LIST: rowVal = None else: rowVal = row.getValue(field) except: print "Could not get row val for field" + field rowVal = None if (rowVal is not None) and (rowVal != ''): try: fieldValAsString = str(row.getValue(field)) messageFile.write("\t\t<" + field + ">" + fieldValAsString + "</" + field + ">\n") except: #fixed issue #19 fieldValAsString = row.getValue(field) decodedstring = fieldValAsString.encode( 'ascii', 'ignore') arcpy.AddMessage( "trying to fix unicode problem, changing " + fieldValAsString + " -> " + decodedstring) messageFile.write("\t\t<" + field + ">" + decodedstring + "</" + field + ">\n") ###################Common Fields/Attributes##################### # Ex: messageFile.write("\t</geomessage>\n") messageFile.write("\t</%s>\n" % MilitaryUtilities.getMessageTag()) # Ex: messageFile.write("</geomessages>") messageFile.write("</%s>\n" % MilitaryUtilities.getMessageRootTag()) arcpy.AddMessage("Rows Processed: " + str(rowCount)) if foundEmptySIDC: arcpy.AddWarning( "IMPORTANT: Some rows did not have SIDC set - you may need to run CalcSIDCField tool first." ) arcpy.AddMessage("Write/Append Message File Complete") except: print "Exception: " tb = traceback.format_exc() print tb arcpy.AddError("Exception") arcpy.AddError(tb)
##Create string list of domains domlist = [] for domain in domains: domlist.append(str(domain)) ##Run through list of domains and create table outputs for dom in domlist: print dom issue = "/" if issue in dom: newdome = dom.replace("/", "") print newdome output = newdome + ".dbf" arcpy.DomainToTable_management(sde, dom, output, "CODE", "DESCR") arcpy.AddField_management(output, "DOMAIN", "TEXT", "", "", 100) else: output = dom + ".dbf" arcpy.DomainToTable_management(sde, dom, output, "CODE", "DESCR") arcpy.AddField_management(output, "DOMAIN", "TEXT", "", "", 100) arcpy.CalculateField_management(output, "DOMAIN", "\"" + dom + "\"", 'PYTHON_9.3') domtableout = outloc + "Domains.dbf" arcpy.Append_management(output, domtableout, "NO_TEST") # Delete Working Folder - Uncomment if required ##arcpy.Delete_management(workingloc)
which prints the domain name and values, also added the line to export the domain to table, for data diagramming @author: kyleg ''' import arcpy indb = r"\\gisdata\planning\Cart\projects\ARNOLD POOLED FUND\geodata\MIRE_GDB_Template_DecodeToTable.gdb" domains = arcpy.da.ListDomains(indb) # @UndefinedVariable for domain in domains: print('Domain name: {0}'.format(domain.name)) if domain.domainType == 'CodedValue': coded_values = domain.codedValues for val, desc in coded_values.iteritems(): print('{0} : {1}'.format(val, desc)) elif domain.domainType == 'Range': print('Min: {0}'.format(domain.range[0])) print('Max: {0}'.format(domain.range[1])) print domain.name outtbl = indb + "/" + domain.name arcpy.DomainToTable_management(in_workspace=indb, domain_name=domain.name, out_table=outtbl, code_field="CODE", description_field="DESC", configuration_keyword="") #arcpy.DomainToTable_management(in_workspace=indb, domain_name=domain.name, out_table=outtbl, code_field="CODE", description_field="DESC", configuration_keyword="")
def main(): # GET PARAMETER VALUES Proposed_Surface_Disturbance_Eligible = arcpy.GetParameterAsText(0) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) # Construct pathname to workspace workspace = arcpy.Describe(Proposed_Surface_Disturbance_Eligible).path arcpy.AddMessage("Project geodatabase: " + workspace) # Instantiate a ccsStandard object ccsStandard = ccslib.ccsStandard(workspace, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace scratch_folder = os.path.join(arcpy.Describe(workspace).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(workspace).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE VARIABLES FOR INPUT DATA # Filenames for feature classes or rasters used by this script ELIGIBLE_PROPOSED_FEATURES = "Proposed_Surface_Disturbance_Eligible" # Filenames for feature classes or rasters created by this script ANALYSIS_AREA = "Analysis_Area" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check tool version ccslib.CheckToolVersion() # Clear selection, if present ccslib.ClearSelectedFeatures(Proposed_Surface_Disturbance_Eligible) # Check Proposed_Surface_Disturbance_Eligible feature = Proposed_Surface_Disturbance_Eligible required_fields = ["Type", "Subtype", "Surface_Disturbance"] no_null_fields = required_fields expected_fcs = None ccslib.CheckPolygonInput(feature, required_fields, expected_fcs, no_null_fields) # Update Proposed_Surface_Disturbance_Elligible layer with provided layer provided_input = Proposed_Surface_Disturbance_Eligible parameter_name = ELIGIBLE_PROPOSED_FEATURES Proposed_Surface_Disturbance_Eligible = ccslib.AdoptParameter( provided_input, parameter_name, preserve_existing=False) # Replace Proposed_Surface_Disturbance_Elibible layer on map layerFile = ccsStandard.getLayerFile("SurfaceDisturbance.lyr") ccslib.AddToMap(Proposed_Surface_Disturbance_Eligible, layerFile) # Update message arcpy.AddMessage("Clipping all anthropogenic features to Analysis Area " "and adding templates for digitizing new anthropogenic " "features") # Clip all provided anthropogenic feature layers and add to map clip_features = ANALYSIS_AREA anthroFeaturePath = ccsStandard.AnthroFeaturePath proposed_anthro = Proposed_Surface_Disturbance_Eligible fieldsToAdd = ["Overlap_Status", "Returned", "Subtype_As_Modified"] fieldTypes = ["TEXT", "TEXT", "TEXT"] mod_field = fieldsToAdd[0] removed_code = "Removed" retained_code = "Retained" ccslib.ClipAnthroFeaturesDebit(clip_features, anthroFeaturePath, proposed_anthro, fieldsToAdd, fieldTypes, mod_field, removed_code, retained_code) # Apply domains for Overlap_Status field and populate default featureList = arcpy.ListFeatureClasses("Anthro_*_Clip") domain_name = fieldsToAdd[0] code_list = ["Retained", "Removed"] ccslib.AddCodedTextDomain(featureList, workspace, domain_name, code_list, assign_default=True, populate_default=True) # Apply domains for Returned field domain_name = fieldsToAdd[1] code_list = ["True", "False"] ccslib.AddCodedTextDomain(featureList, workspace, domain_name, code_list, assign_default=True, populate_default=True) # Add all Subtype anthro domains because ArcGIS doesn't transfer them # consistently desc_c = arcpy.Describe(workspace) current_domains = desc_c.domains desc_w = arcpy.Describe(ccsStandard.AnthroFeaturePath) anthro_domains = desc_w.domains for domain_name in anthro_domains: if domain_name not in current_domains and "Subtype" in domain_name: source_workspace = ccsStandard.AnthroFeaturePath code_field = 'code' description_field = 'description' domain_table = arcpy.DomainToTable_management( source_workspace, domain_name, domain_name, code_field, description_field) arcpy.TableToDomain_management(domain_table, code_field, description_field, workspace, domain_name) arcpy.Delete_management(domain_table) # Apply domains for each anthro feature for feature in featureList: # Apply for each Subtype field field = "Subtype" domainName = feature[7:-5] + "_Subtypes" arcpy.AssignDomainToField_management(feature, field, domainName) subtypes = arcpy.da.ListSubtypes(feature) if len(subtypes) == 1 and subtypes[0]['SubtypeField'] == '': pass else: st_codes = [ str(stcode) for stcode, stdict in list(subtypes.items()) ] arcpy.AssignDomainToField_management(feature, field, domainName, st_codes) # Apply for each Subtype As Modified Field field = fieldsToAdd[-1] domainName = feature[7:-5] + "_Subtypes" arcpy.AssignDomainToField_management(feature, field, domainName) subtypes = arcpy.da.ListSubtypes(feature) if len(subtypes) == 1 and subtypes[0]['SubtypeField'] == '': pass else: st_codes = [ str(stcode) for stcode, stdict in list(subtypes.items()) ] arcpy.AssignDomainToField_management(feature, field, domainName, st_codes) # Copy current subtype to Subtype as Modified field arcpy.CalculateField_management(feature, field, "!Subtype!", "PYTHON_9.3") # Add each feature to map for editing for feature in featureList: ccslib.AddAnthroToMap(workspace, feature) # Save map document and exit if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
updatefields.append(symbolNameFieldName) if (EchelonField in fieldNameList): updatefields.append(EchelonField) for field in desc.Fields: if field.name in updatefields: # Get domain if any if (field.domain is not None and field.domain != ""): fieldNameToDomainName[field.name] = field.domain if arcpy.Exists("in_memory/" + field.domain): arcpy.Delete_management("in_memory/" + field.domain) try: #If path is feature class arcpy.DomainToTable_management(desc.path, field.domain, "in_memory/" + field.domain, CODE_FIELD_NAME, DESCRIPTION_FIELD_NAME) except: #If path is feature dataset arcpy.DomainToTable_management( arcpy.Describe(desc.path).path, field.domain, "in_memory/" + field.domain, CODE_FIELD_NAME, DESCRIPTION_FIELD_NAME) with arcpy.da.UpdateCursor(inputFC, updatefields) as cursor: for row in cursor: #Lookup Symbol ID Value SymbolIdCodeVal = "" echelonString = "" if (symbolNameFieldName in fieldNameToDomainName): domain = fieldNameToDomainName[symbolNameFieldName]
def export_domains(domains): for domain in domains: arcpy.AddMessage('Exporting %s CV to table in %s' % (domain.name, gdb)) table = os.path.join(gdb, domain.name) arcpy.DomainToTable_management(gdb, domain.name, table, 'field','description', '#')
expression_type="VB", code_block="") arcpy.AddField_management(in_table="GC_UNCO_DESPOSIT", field_name="joinstr", field_type="TEXT", field_precision="", field_scale="", field_length="800", field_alias="", field_is_nullable="NULLABLE", field_is_required="NON_REQUIRED", field_domain="") arcpy.DomainToTable_management( in_workspace="D:/CCW20/GIS/geocover.gdb", domain_name="GC_LITHO_UNCO_CD", out_table="D:/CCW20/GIS/geocover.gdb/domain_GC_LITHO_UNCO_CD", code_field="code", description_field="GC_LITHO_UNCO_CD", configuration_keyword="") arcpy.DomainToTable_management( in_workspace="D:/CCW20/GIS/geocover.gdb", domain_name="GC_LITSTRAT_UNCO_CD", out_table="D:/CCW20/GIS/geocover.gdb/domain_GC_LITSTRAT_UNCO_CD", code_field="code", description_field="GC_LITSTRAT_UNCO_CD", configuration_keyword="") arcpy.DomainToTable_management( in_workspace="D:/CCW20/GIS/geocover.gdb", domain_name="GC_UN_DEP_RUNC_STRUCTUR_CD", out_table="D:/CCW20/GIS/geocover.gdb/domain_GC_UN_DEP_RUNC_STRUCTUR_CD", code_field="code",