Skip To Content

Metadata

Zusammenfassung

The Metadata class allows you to access an item's metadata, and export metadata to a standard metadata format. If you have appropriate privileges, the class allows you to modify an item's metadata, or import a standard-format metadata XML file's content to an item.

Syntax

Metadata
 ({uri})
ParameterErklärungDatentyp
uri

A URI that identifies the item whose metadata you want to update.

String

When a URI is provided, the Metadata object returned will provide access to the metadata for the item identified by the URI. If metadata hasn't been created yet to describe the item, and you have sufficient privileges to create it, metadata will be created for the item and the contents of the new metadata document will be represented by the object returned. If the item doesn't support metadata, or if the item doesn't exist, an empty object is created; changes can't be saved back to the item.

When the Metadata object is created without providing a URI, an empty object is created. You can create or import metadata using the Metadata object, then save its content to a new XML file or to another item as its metadata.

You can also get a Metadata object from projects, maps, map layers, layouts, and reports and use the object to access and manage their metadata.

Create a Metadata object and define its content, then get a Metadata object for a feature class. Assign content from the new Metadata object to the feature class.

import arcpy
from arcpy import metadata as md

# Create a new Metadata object and add some content to it
new_md = md.Metadata()
new_md.title = 'My Title'
new_md.tags = 'Tag1, Tag2'
new_md.summary = 'My Summary'
new_md.description = 'My Description'
new_md.credits = 'My Credits'
new_md.accessConstraints = 'My Access Constraints'

# Assign the Metadata object's content to a target item
streets_path = r'C:\Data\LocalArea.gdb\Streets'
tgt_item_md = md.Metadata(streets_path)
if not tgt_item_md.isReadOnly:
    tgt_item_md.copy(new_md)
    tgt_item_md.save()

Get a Metadata object from a project.

import arcpy
aprx = arcpy.mp.ArcGISProject(r"C:\Projects\data_management.aprx")
aprx_metadata = aprx.metadata
print(aprx_metadata.title)
print(aprx_metadata.description)

Get a Metadata object from the current map, using the Python window.

import arcpy
aprx = arcpy.mp.ArcGISProject("CURRENT")
current_map = aprx.activeMap
map_metadata = current_map.metadata
print(map_metadata.title)
print(map_metadata.description)

Get a Metadata object from a map layer.

import arcpy
aprx = arcpy.mp.ArcGISProject(r"C:\Projects\data_management.aprx")
layer = aprx.listMaps()[0].listLayers()[0]
layer_metadata = layer.metadata
print(layer_metadata.title)
print(layer_metadata.description)

Eigenschaften

EigenschaftErklärungDatentyp
accessConstraints
(Lesen und schreiben)

Documented limitations with respect to using the item. Derived from Use Limitations defined in the item's metadata.

String
credits
(Lesen und schreiben)

Information that gives credit to the producer or provider of the item. Derived from Credits defined in the item's metadata.

String
description
(Lesen und schreiben)

A description of the item. Derived from the Description (Abstract), or for geoprocessing tools the Summary (Abstract), defined in the item's metadata.

This property may contain plain text, or it may contain a snippet of HTML. When the description is written in the ArcGIS Metadata editor in ArcGIS Desktop or ArcGIS Pro, or in ArcGIS Online or an Enterprise Portal, the description will include HTML tags.

String
isReadOnly
(Nur lesen)

Check if you can update metadata for the item whose metadata is represented by the Metadata object. If a new, empty Metadata object was created, the Metadata object is not yet associated with an item or an XML file on disk, but it will be writable, in that you can modify the contents of the Metadata object and then write it to disk or save the content to an item for which you have the appropriate privileges to edit metadata.

Boolean
maxScale
(Nur lesen)

The maximum map scale at which the item should draw. Derived from the maximum value in the Appropriate Scale Range defined in the item's metadata.

Double
minScale
(Nur lesen)

The minimum map scale at which the item should draw. Derived from the minimum value in the Appropriate Scale Range defined in the item's metadata.

Double
summary
(Lesen und schreiben)

A summary describing the purpose of the item. Derived from the Summary (Purpose) defined in the item's metadata.

String
tags
(Lesen und schreiben)

A set of tags that describe the item. Derived from Tags defined in the item's metadata. The value is a string that defines a comma-separated sequence of tags.

String
thumbnailUri
(Lesen und schreiben)

A local or network path, or a URL, to a graphic file that describes and helps to identify the item. Derived from the Thumbnail that is extracted from the item's metadata. When setting this value, if a URL is provided, the identified file will be downloaded and incorporated into the item’s metadata.

String
title
(Lesen und schreiben)

A descriptive title for the item. Derived from the Title in the item's metadata.

String
xmax
(Nur lesen)

The maximum value along the x-axis for the item’s minimum bounding rectangle. Derived from the East coordinate of the Bounding Box recorded in the item's metadata.

Double
xmin
(Nur lesen)

The minimum value along the x-axis for the item’s minimum bounding rectangle. Derived from the West coordinate of the Bounding Box recorded in the item's metadata.

Double
xml
(Lesen und schreiben)

The item’s ArcGIS metadata XML document as a string. Not all items support metadata. When you are getting an item’s metadata, be sure to check for an empty string as the return value.

String
ymax
(Nur lesen)

The maximum value along the y-axis for the item’s minimum bounding rectangle. Derived from the North coordinate of the Bounding Box recorded in the item's metadata.

Double
ymin
(Nur lesen)

The minimum value along the y-axis for the item’s minimum bounding rectangle. Derived from the South coordinate of the Bounding Box recorded in the item's metadata.

Double

Methodenübersicht

MethodeErklärung
copy (inputMetadata)

Copy metadata content from the input Metadata object to the current Metadata object. For example, this supports copying metadata from one item to another item.

importMetadata (sourceUri, {metadata_import_option}, {customStylesheetPath})

Import content to the Metadata object from the item identified by the sourceURI.

exportMetadata (outputPath, {metadata_export_option}, {metadata_removal_option}, {customStylesheetPath})

Converts a Metadata object that represents an item's metadata to a standard-format metadata XML file.

reload ()

The Metadata object is reinitialized with the item's current metadata content.

save ()

Save updates made to the content in the Metadata object back to the original item from which the Metadata object was derived.

saveAsUsingCustomXSLT (outputPath, customStylesheetPath)

Saves a copy of the item's ArcGIS metadata to a stand-alone metadata XML file using a custom XSLT stylesheet.

saveAsXML (outputPath, {metadata_save_as_xml_option})

Save a copy of the item's ArcGIS metadata to a stand-alone metadata XML file.

synchronize (metadata_sync_option, interval)

Updates metadata content in the item with the current properties of the item and reloads that content into the Metadata object.

upgrade (metadata_upgrade_option)

Upgrades the metadata of the current item.

Methoden

copy (inputMetadata)
ParameterErklärungDatentyp
inputMetadata

A Metadata object that is created and populated with metadata content in the ArcGIS metadata format. For example, this Metadata object can be derived from a source feature class and copied to the feature class associated with the current Metadata object.

Object

An item's metadata must be stored in the ArcGIS metadata XML format. Only metadata content in the ArcGIS metadata format can be copied.

Copy metadata from a metadata template to a map in the current project.

import arcpy
from arcpy import metadata as md

# Get metadata content from a metadata template XML file
template_path = r'C:\Metadata\ArcGIS_metadata_template.xml'
src_item_md = md.Metadata(template_path)

# Copy the template's content to a map in the project
current_aprx = arcpy.mp.ArcGISProject('CURRENT')
map0 = current_aprx.listMaps()[0]
map0_md = map0.metadata
map0_md.copy(src_item_md)
map0_md.save()
current_aprx.save()
importMetadata (sourceUri, {metadata_import_option}, {customStylesheetPath})
ParameterErklärungDatentyp
sourceUri

A URI that identifies an item from which metadata will be imported to the Metadata object.

String
metadata_import_option

This option determines how content is imported to the Metadata object from the source item. This value indicates the XML format of metadata stored in the source item. The source item's content will be converted from the indicated format to the ArcGIS metadata XML format before being saved to the Metadata object.

  • CUSTOM A custom XSLT stylesheet will be used to convert from another XML format to the ArcGIS metadata XML format.
  • DEFAULT Use this option if you are importing metadata from a stand-alone metadata XML file and you are unsure what XML format it uses. The document's format will be checked, and the correct conversion will be performed to transform its content to the ArcGIS metadata XML format.
  • FGDC_CSDGM The stand-alone metadata XML file has content stored in the FGDC CSDGM XML format.
  • ISO19139The stand-alone metadata XML file has content stored in the ISO 19139 XML format, and must have the GML namespace appropriate for the 2007 version of the ISO 19139 XML Schemas: http://www.opengis.net/gml.
  • ISO19139_GML32The stand-alone metadata XML file has content stored in the ISO 19139 XML format, and must have the GML namespace appropriate for the 2012 version of the ISO 19139 XML Schemas: http://www.opengis.net/gml/3.2.
  • ISO19139_UNKNOWN The stand-alone metadata XML file has content stored in the ISO 19139 XML format. Use this option if you are unsure which GML namespace the document uses. The namespace is checked and the correct conversion will be performed to transform the document's content to the ArcGIS metadata XML format.
  • ARCGIS_METADATA An ArcGIS item or a stand-alone metadata XML document is identified as the source item. The source item's metadata is not converted to the ArcGIS metadata XML format because it is already in the correct format.

(Der Standardwert ist DEFAULT)

String
customStylesheetPath

A local or network file path, or a URL, identifying the custom XSLT stylesheet that will be used to import metadata from a custom XML format. The value in this parameter will only be considered if the metadata_export_option is CUSTOM. If a URL, the referenced file will be downloaded, and the downloaded file will be used.

String

An item's metadata must be stored in the ArcGIS metadata XML format. The imported XML file will be converted from the standard metadata XML format to the ArcGIS metadata format using the conversion identified by the metadata_import_option. The resulting content is stored in the Metadata object. Many of the item's properties, its thumbnail, and geoprocessing history will remain. However, any metadata content that was previously typed using a metadata editor will be removed and replaced by the imported metadata content.

If the format of the stand-alone metadata file has an XML format that does not match the format specified by the metadata_import_option, the wrong conversion will be performed and there will be no metadata content to import to the item. However, the item's existing typed metadata content will still be removed as part of the process.

Import metadata content from a standard-format XML file, when you are not sure of the file's format. The DEFAULT import option detects the file's format and converts it to the ArcGIS metadata format.

import arcpy
from arcpy import metadata as md

# Set the standard-format metadata XML file's path
src_file_path = r'C:\Metadata\trees_metadata.xml'

# Get the target item's Metadata object
trees_path = r'C:\Data\LocalArea.gdb\Trees'
tgt_item_md = md.Metadata(trees_path)

# Import the standard-format metadata content to the target item
if not tgt_item_md.isReadOnly:
    tgt_item_md.importMetadata(src_file_path)
    tgt_item_md.save()

Import metadata content from an FGDC CSDGM-format XML file to a target item.

import arcpy
from arcpy import metadata as md

# Get the standard-format metadata XML file's object
src_csdgm_path = r'C:\Metadata\parks_csdgm.xml'

# Get the target item's Metadata object
parks_path = r'C:\Data\LocalArea.gdb\Parks'
tgt_item_md = md.Metadata(parks_path)

# Import the standard-format metadata content to the target item
if not tgt_item_md.isReadOnly:
    tgt_item_md.importMetadata(src_csdgm_path, 'FGDC_CSDGM')
    tgt_item_md.save()
exportMetadata (outputPath, {metadata_export_option}, {metadata_removal_option}, {customStylesheetPath})
ParameterErklärungDatentyp
outputPath

The output XML file.

String
metadata_export_option

Specifies how the item's metadata is exported. The value indicates what XML format will be used by the output XML file. The item's ArcGIS metadata content will be converted to the appropriate XML format.

  • CUSTOM A custom XSLT stylesheet will be used to convert metadata content stored in the item from ArcGIS metadata to another XML format.
  • FGDC_CSDGM The exported metadata document will have content stored in the FGDC CSDGM XML format.
  • ISO19139The exported metadata document will have content stored in the ISO 19139 XML format. The GML namespace used in the output file is appropriate for the 2007 version of the ISO 19139 XML Schemas: http://www.opengis.net/gml.
  • ISO19139_GML32The exported metadata document will have content stored in the ISO 19139 XML format. The GML namespace used in the output file is appropriate for the 2012 version of the ISO 19139 XML Schemas: http://www.opengis.net/gml/3.2.
  • ISO19115_ 3The exported metadata document will have content stored in the ISO 19115-3 XML format.

(Der Standardwert ist ISO19139)

String
metadata_removal_option

Specifies whether sensitive information is removed from the item's metadata as part of the export process. The value indicates what content is filtered out. The remaining metadata content is exported.

  • EXACT_COPY The metadata content is not filtered before it is exported to a standard metadata format. All content is exported, including any sensitive information that may be present.
  • REMOVE_ALL_SENSITIVE_INFO The metadata content is filtered to remove local file paths, database connection information, URLs that do not begin with http or https, and so on, if this information is present. The remaining metadata content is exported.
  • REMOVE_MACHINE_NAMES The metadata content is filtered to remove machine names from UNC paths, if they are present. The remaining metadata content is exported.

(Der Standardwert ist REMOVE_ALL_SENSITIVE_INFO)

String
customStylesheetPath

A local or network file path, or a URL, identifying the custom XSLT stylesheet that will be used to export metadata to a custom XML format. The value in this parameter will only be considered if the metadata_export_option is CUSTOM. If a URL, the referenced file will be downloaded, and the downloaded file will be used.

String

An item’s metadata is stored in the ArcGIS metadata XML format. The item's metadata will be converted to a standards-compliant metadata XML format as identified by the metadata_export_option parameter. The resulting XML document will be saved to an XML file.

Before the item's metadata is converted, you can choose to filter an item's ArcGIS metadata content or not. For example, if you plan to share the exported metadata document with people outside your organization, it is a good idea to exclude any information that may be considered sensitive to your organization. The amount of content that is filtered is determined by the metadata_removal_option parameter.

Before the export process begins, you may want to synchronize the item's metadata so it contains the most up-to-date properties of the data.

Synchronize an item's properties, and export the most current metadata content. Export the item's metadata to a standard metadata XML format to share this information outside the ArcGIS platform.

import arcpy
from arcpy import metadata as md

# Get the source item's Metadata object
streets_path = r'C:\Data\LocalArea.gdb\Streets'
src_item_md = md.Metadata(streets_path)

# Synchronize the item's metadata now
src_item_md.synchronize('ALWAYS')

# Export the item's metadata using the default export format (ISO 19139)
# after removing sensitive information from the metadata, if it exists.
export_19139_path = r'C:\MetadataExport\streets_19139.xml'
src_item_md.exportMetadata(export_19139_path,
                           metadata_removal_option='REMOVE_ALL_SENSITIVE_INFO')

# Export the item's metadata to the FGDC CSDGM XML format as well
export_csdgm_path = r'C:\MetadataExport\streets_csdgm.xml'
src_item_md.exportMetadata(export_csdgm_path, 'FGDC_CSDGM',
                           'REMOVE_ALL_SENSITIVE_INFO')

# Export the metadata using the specified custom XSLT stylesheet, for 
# example, to generate a custom HTML format for display outside ArcGIS
export_custom_path = r'C:\MetadataExport\streets_custom.html'
custom_html_export_path = r'C:\MetadataExport\custom_html_output.xslt'
src_item_md.exportMetadata(export_custom_path, 'CUSTOM',
                           'REMOVE_ALL_SENSITIVE_INFO',
                           custom_html_export_path)
reload ()

The Metadata object is initialized with an item's metadata. In the process of your work, it is possible that the item's metadata content could be modified by an external process. This function allows you to reload the item's current metadata content into the Metadata object. For example, if you save changes to an item's metadata using the ArcGIS Pro metadata editor, that change would not be immediately reflected in the Metadata object you are working with in the Python window. Use this function to reinitialize the Metadata object before continuing with your work.

Reload the item's metadata from the source to see the latest changes. This script is designed to work in the Python window.

import arcpy
from arcpy import metadata as md

# Get a map layer's Metadata object
aprx = arcpy.mp.ArcGISProject("CURRENT")
currentMap = aprx.activeMap
first_lyr = currentMap.listLayers()[0]
lyr_metadata = first_lyr.metadata

# Print the original set of tags
lyr_tags_orig = lyr_metadata.tags
if lyr_tags_orig is not None:
    print('Original tags: ' + lyr_tags_orig)
else:
    print('Original tags: None')

# Update tags in the item's metadata, but don't save the changes
lyr_metadata.tags = 'Apple, Banana, Cherry'

# Print the updated set of tags
print('Updated tags: ' + lyr_metadata.tags)

# Reloading metadata lets you access updates made externally,
# but you will lose any unsaved changes
lyr_metadata.reload()

# Print the reloaded set of tags
lyr_tags_reload = lyr_metadata.tags
if lyr_tags_reload is not None:
    print('Reloaded tags: ' + lyr_tags_reload)
else:
    print('Reloaded tags: None')
save ()

As you make changes to the metadata content stored in the Metadata object, those changes are not automatically saved back to the item from which the Metadata object was derived. Changes will only be saved back to the item when the save function is used. You must have the appropriate privileges to update the original item's metadata.

For example, if the Metadata object represents the metadata for a map in the current project, this function will update the map's metadata. For items stored in a project, metadata changes aren't truly saved until the project is saved; if the project is closed without saving, the changes you made to the map's metadata will be lost.

If a new, empty Metadata object was created and you add content to this new metadata document, this function will fail with an error message since it is not associated with an existing item. Assign the Metadata object to an item to update its metadata with the content defined in the Metadata object.

Update the tags in an item's metadata. You must have the appropriate privileges to update an item's metadata.

import arcpy
from arcpy import metadata as md

# Get the target item's Metadata object
hydrants_path = r'C:\Data\LocalArea.gdb\Hydrants'
item_md = md.Metadata(hydrants_path)

# Save the changes if you have privileges in the geodatabase to do so
if not item_md.isReadOnly:
    # Update the tags in the item's metadata, then save the changes
    item_md.tags = 'One, Two, Three'
    tgt_item_md.save()
saveAsUsingCustomXSLT (outputPath, customStylesheetPath)
ParameterErklärungDatentyp
outputPath

The output XML file.

String
customStylesheetPath

A local or network file path, or a URL, identifying the custom XSLT stylesheet that will be used to transform the item's ArcGIS metadata. If a URL, the referenced file will be downloaded, and the downloaded file will be used.

String

Use a custom XSLT stylesheet to modify an item's ArcGIS metadata and save the result to an XML file. The updated metadata content is then saved back to the original item. The custom XSLT stylesheet used in this example is one that was provided with ArcMap to remove an item's geoprocessing history from its metadata, and which will continue to work with ArcGIS Pro.

import arcpy
from arcpy import metadata as md

# Get the item's Metadata object
street_lights_path = r'C:\Data\LocalArea.gdb\StreetLights'
src_item_md = md.Metadata(street_lights_path)

# Save the item's metadata to an xml file using a custom XSLT
target_file_path = r'C:\MetadataInternal\street_lights_no_gp_history.xml'
custom_xslt_path = r'C:\MetadataInternal\remove geoprocessing history.xslt'
src_item_md.saveAsUsingCustomXSLT(target_file_path, custom_xslt_path)

# Save the modified ArcGIS metadata output back to the source item
tgt_item_md = md.Metadata(target_file_path)
src_item_md.copy(tgt_item_md)
src_item_md.save()
saveAsXML (outputPath, {metadata_save_as_xml_option})
ParameterErklärungDatentyp
outputPath

The output XML file. The output file will contain metadata stored in the ArcGIS Metadata XML format.

String
metadata_save_as_xml_option

Specifies whether information is removed from the item's metadata as part of the process of saving the item's metadata to a stand-alone metadata XML file. The value indicates the amount and type of content that is filtered out of the item's metadata.

  • EXACT_COPY The content of the item's current metadata is not filtered before it is saved to the output file.
  • REMOVE_ALL_SENSITIVE_INFO The content of the item's metadata is filtered to remove local file paths, database connection information, URLs that do not begin with http or https, and so on, if this information is present. The remaining metadata content is then saved to the output file.
  • REMOVE_MACHINE_NAMES The content of the item's metadata is filtered to remove machine names from UNC paths, if they are present. The remaining metadata content is then saved to the output file.
  • TEMPLATE The content of the item's metadata is filtered to remove content describing properties of the item from its metadata, if this information is present. The remaining metadata content is then saved to the output file. This file would be suitable to use as the basis for a metadata template.

(Der Standardwert ist EXACT_COPY)

String

Save two copies of an item's ArcGIS metadata to disk. One copy exactly matches the metadata that is stored with the item, and the other file's metadata content has been filtered to remove sensitive content.

import arcpy
from arcpy import metadata as md

# Get the item's Metadata object
street_lights_path = r'C:\Data\LocalArea.gdb\StreetLights'
src_item_md = md.Metadata(street_lights_path)

# Save a copy of the item's metadata to an xml file as a backup.
# This copy is for internal use only.
target_copy_path = r'C:\MetadataInternal\street_lights_copy.xml'
src_item_md.saveAsXML(target_copy_path)

# Save a version of the item's metadata without sensitive information
# separately so it can be shared externally.
target_filtered_path = r'C:\MetadataExternal\street_lights_no_sensitive.xml'
src_item_md.saveAsXML(target_filtered_path, 'REMOVE_ALL_SENSITIVE_INFO')
synchronize (metadata_sync_option, interval)
ParameterErklärungDatentyp
metadata_sync_option

Specifies how and which elements in the metadata are updated with current properties of the data.

Some metadata elements should always be derived from the item's properties, such as its spatial reference. Some metadata elements can be initialized by the properties of the item, but would typically be updated by a person to better characterize the item before the metadata is shared, such the title of the item.

When a metadata element is created and its value is initialized by synchronization, the XML element in which the value is stored has a Sync attribute, and its value is set to True. Typically, a metadata element's value will only be synchronized when the Sync attribute is set to True. When the element's value is updated using the ArcGIS metadata editor, the Sync attribute is removed. Alternatively, an application could change the attribute's value to False to achieve the same result.

  • ACCESSEDProperties are updated in the item's metadata for appropriate metadata elements where the Sync attribute value is True. The update will take place if at least the amount of time specified by the interval parameter has elapsed since the last time the item's metadata content was synchronized. Metadata is created if it doesn't already exist.
  • ALWAYSProperties are updated in the item's metadata for appropriate metadata elements where the Sync attribute value is True. Metadata content will be updated appropriately at the time the function is used; a time specified by the interval parameter is not used, if one has been provided. Metadata is created if it doesn't already exist.
  • CREATEDMetadata is created and properties are added to it only if metadata doesn't exist yet for the item.
  • NOT_CREATEDProperties are updated in existing metadata only. Appropriate element values are updated if its Sync attribute value is True.
  • OVERWRITEAll property values that can be synchronized are updated in the item's metadata, regardless of the value or presence of the Sync attribute on these metadata elements. After this function is used, all metadata elements that have been updated will have a Sync attribute with the value True. For example, after copying metadata from one item to another, use this option to initialize all properties in a manner that is appropriate for the item, including the title, which should be changed to match the new item's name instead of using a title that describes the old item.Metadata content will be updated appropriately at the time the function is used; a time specified by the interval parameter is not used, if one has been provided. Metadata is created if it doesn't already exist.
  • SELECTIVEGenerally the same as the OVERWRITE option. However, the values of the Title and Content Type metadata elements are not updated. For example, if you import a standard-format metadata document to the item that describes the item's data, the title in the imported document does apply to the item, and it will not be overwritten. All other properties in the item's metadata will be initialized in a manner appropriate for the item.Metadata content will be updated appropriately at the time the function is used; a time specified by the interval parameter is not used, if one has been provided. Metadata is created if it doesn't already exist.
String
interval

The number of seconds that should elapse before the item is synchronized again. For example, if the Metadata object represents a feature class in a geodatabase and another user has recently synchronized the item's metadata, this function will not synchronize the item's metadata content again unless sufficient time has passed. Providing a value of zero will cause the item's metadata to be synchronized again immediately.

The interval is only considered when the metadata_sync_option value is ACCESSED, CREATED, and NOT_CREATED.

Integer

If the Metadata object represents a feature class's metadata, this function will update the metadata content to reflect current properties of the data, such as the number of features it has, its spatial reference, the current list of attributes, and so on. If the item doesn't have any metadata content, it may or may not be created for the item, depending on the metadata_sync_option. Also, the interval time is considered, depending on the metadata_sync_option.

Some metadata elements should always be derived from the item's properties, such as its spatial reference. Some metadata elements can be initialized by the properties of the item, but would typically be updated by a person to better characterize the item before the metadata is shared, such the title of the item. The metadata_sync_option determines which properties of the item are updated, and how metadata elements are handled if a person has typed a value in that element.

Import metadata content from an ISO 19139-format XML file to a feature class, and update the properties of the feature class that are recorded in the metadata so they match the item's current properties.

import arcpy
from arcpy import metadata as md

# Get the standard-format metadata XML file's object
src_19139_path = r'C:\Metadata\street_lights_19139.xml'

# Get the target item's Metadata object
street_lights_path = r'C:\Data\LocalArea.gdb\StreetLights'
tgt_item_md = md.Metadata(street_lights_path)

if not tgt_item_md.isReadOnly:
    # Import standard-format metadata content to the target item 
    tgt_item_md.importMetadata(src_19139_path, 'ISO19139_UNKNOWN')
    tgt_item_md.save()
    
    # Use SELECTIVE so you don't lose the imported title
    # other properties will update on synchronize as data changes
    tgt_item_md.synchronize('SELECTIVE')
upgrade (metadata_upgrade_option)
ParameterErklärungDatentyp
metadata_upgrade_option

Specifies how the item's metadata will be upgraded to the ArcGIS metadata format. This option is provided to update metadata that was created with ArcGIS Desktop 8.x or 9.x.

  • ESRI_ISO ESRI-ISO format metadata content included in the item's metadata will be upgraded to the ArcGIS metadata format. This metadata content would have been authored using the ArcGIS Desktop ISO Metadata Wizard editor.
  • FGDC_CSDGM FGDC CSDGM format metadata content included in the item's metadata will be upgraded to the ArcGIS metadata format. This metadata content would have been authored using the ArcGIS Desktop FGDC CSDGM Metadata editor.
String

A Metadata document that was created with ArcGIS Desktop 8.x or 9.x can be upgraded to the ArcGIS metadata format.

Upgrade an archived item's ArcGIS Desktop 9.x metadata content to the ArcGIS metadata format.

import arcpy
from arcpy import metadata as md

# Get the item's Metadata object
archive_item_path = r'C:\Data\Old.gdb\Buildings'
archive_item_md = md.Metadata(archive_item_path)

# Upgrade the item's metadata content to the ArcGIS metadata format
archive_item_md.upgrade('FGDC_CSDGM')

Codebeispiel

Metadata example

Access information that describes an item from its metadata.

import arcpy
from arcpy import metadata as md

highways_path = r'C:\Data\LocalArea.gdb\Highways'
item_md = md.Metadata(highways_path)

print("Title:", item_md.title)
print("Tags:", item_md.tags)
print("Summary:", item_md.summary)
print("Description:", item_md.description)
print("Credits:", item_md.credits)
print("Access Constraints:", item_md.accessConstraints)