def to_package(self, output_file, summary, tags, **kwargs):
"""
Though it's not normally a mapping method, packaging concepts need translation between the two versions, so
we've included to_package for maps and projects. In ArcGIS Pro, project.to_package will create a Project Package
and map.to_package will create a map package. In ArcMap, both will create a map package. Extra **kwargs beyond
output path are only passed through to Pro Package command, not to map packages. To pass kwargs through to a map
package, use a map object's to_package method.
:param output_file: the path to output the package to
:param kwargs: dictionary of kwargs to pass through to project packaging in Pro.
:return: None
"""
log.warning("Warning: Saving project to export package")
self.save()
if PRO:
arcpy.PackageProject_management(self.path,
output_file,
summary=summary,
tags=tags,
**kwargs)
else:
arcpy.PackageMap_management(self.path,
output_file,
summary=summary,
tags=tags)
def create_mpk(data_location, mxd, additional_files=None):
"""Creates a map package (.mpk) for all the datasets in the data location.
:param data_location: location of data to be packaged
:param mxd: existing map document template (mxd path)
:param additional_files: list of additional files to include in the package
"""
import arcpy
arcpy.PackageMap_management(mxd, mxd.replace('.mxd', '.mpk'),
'PRESERVE', version='10', additional_files=additional_files)
make_thumbnail(mxd, os.path.join(os.path.dirname(data_location), '_thumb.png'))
def to_package(self, output_file, **kwargs):
"""
Though it's not normally a mapping method, packaging concepts need translation between the two versions, so
we've included to_package for maps and projects. In ArcGIS Pro, project.to_package will create a Project Package
and map.to_package will create a map package. In ArcMap, both will create a map package. Calling to_package on the map
will pass through all kwargs to map packaging because the signatures are the same between ArcMap and ArcGIS Pro.
Sending kwargs to project.to_package will only send to project package since they differ.
:param output_file:
:param kwargs:
:return:
"""
log.warning("Warning: Saving map to export package")
self.project.save()
if PRO:
arcpy.PackageMap_management(self.map_object, output_file, **kwargs)
else:
arcpy.PackageMap_management(self.project.path, output_file,
**kwargs)
def mpkExport(arguments):
"""
Goes through the list of mxds in the given directory and tries to export them as mpks.
Needs:
arguments: the list of arguments from the parser in main()
"""
workspace = arguments.inDir
output = arguments.outDir
logDir = arguments.logDir
logName = arguments.logName
error_count = 0
# Set environment settings
arcpy.env.overwriteOutput = True
arcpy.env.workspace = workspace
mxdlist = arcpy.ListFiles("*.mxd")
# Create a logfile
log = createLogfile(logDir, logName)
if len(mxdlist) < 1:
error_count -= 1
else:
# Loop through the workspace, find all the mxds and create a map package using the same name as the mxd
for mxd in mxdlist:
print("Packaging " + mxd)
outPath = output + '\\' + os.path.splitext(mxd)[0]
try:
arcpy.PackageMap_management(mxd, outPath + '.mpk', "PRESERVE",
"CONVERT_ARCSDE", "#", "ALL",
"RUNTIME")
print("SUCCESS: " + mxd + " processed successfully.")
# if a packaging folder was created, it will be removed
if os.path.exists(outPath):
try:
shutil.rmtree(outPath, onerror=remove_readonly)
except Exception as e:
error_count += 1
writeLog(log, e, error_count, mxd)
print(
"Removal of package directory " + outPath +
" failed. Consider running the script with administrator permissions."
)
except Exception as e:
error_count += 1
writeLog(log, e, error_count, mxd)
print("ERROR while processing " + mxd)
# close the Logfile
closeLog(log, error_count)
Resumen = arcpy.GetParameterAsText(3) #Variable para el resumen
Descripcion = arcpy.GetParameterAsText(4) #Variable para la descripción
#Etiqueta = arcpy.GetParameterAsText(5) #Variable para las etiquetas. Las etiquetas se separan por comas (,)
for dirpath, subdirs, files in os.walk(source):
for x in files:
if x.endswith(".mxd"):
mxdList.append(os.path.join(dirpath, x))
arcpy.AddMessage("\n")
arcpy.AddMessage("Procesando: ")
for mxd in mxdList:
mpk = mxd.replace(".mxd", ".mpk")
MXDpath = mxd
mapdoc = arcpy.mapping.MapDocument(MXDpath)
MPKpath = mpk
if Booleano == "true":
mapdoc.title = Titulo #mapdoc.filePath Cambiar despues a nombre del MXD
mapdoc.summary = Resumen
mapdoc.description = Descripcion
mapdoc.tags = "Mapas"
mapdoc.save()
arcpy.PackageMap_management(MXDpath, MPKpath)
arcpy.AddMessage("El archivo MXD fue exportado en:" + MPKpath)
del mapdoc
def export_map_document(product_location,
mxd,
map_doc_name,
data_frame,
outputdirectory,
export_type,
production_xml=None):
"""Exports MXD to chosen file type"""
try:
export = export_type.upper()
product = arcpy.ProductInfo()
arcpy.AddMessage("Product: " + product)
if product == 'ArcServer':
filename_prefixe = "_ags_"
else:
filename_prefixe = ""
if export == "PDF":
filename = filename_prefixe + map_doc_name + ".pdf"
outfile = os.path.join(outputdirectory, filename)
# Export to PDF optional parameters
data_frame = "PAGE_LAYOUT"
df_export_width = 640
df_export_height = 480
resolution = 300
image_quality = "BEST"
colorspace = "RGB"
compress_vectors = True
image_compression = "ADAPTIVE"
picture_symbol = "RASTERIZE_BITMAP"
convert_markers = False
embed_fonts = True
layers_attributes = "LAYERS_ONLY"
georef_info = True
jpeg_compression_quality = 80
# Run the export tool
arcpy.mapping.ExportToPDF(mxd, outfile, data_frame,
df_export_width, df_export_height,
resolution, image_quality, colorspace,
compress_vectors, image_compression,
picture_symbol, convert_markers,
embed_fonts, layers_attributes,
georef_info, jpeg_compression_quality)
arcpy.AddMessage("PDF is located: " + outfile)
arcpy.AddMessage(filename)
return filename
elif export == 'JPEG':
filename = filename_prefixe + map_doc_name + ".jpg"
outfile = os.path.join(outputdirectory, filename)
# Export to JEPG optional parameters
data_frame = "PAGE_LAYOUT"
df_export_width = 640
df_export_height = 480
resolution = 96
world_file = False
color_mode = "24-BIT_TRUE_COLOR"
jpeg_quality = 100
progressive = False
# Run the export tool
arcpy.mapping.ExportToJPEG(mxd, outfile, data_frame,
df_export_width, df_export_height,
resolution, world_file, color_mode,
jpeg_quality, progressive)
arcpy.AddMessage("JPEG is located: " + outfile)
return filename
elif export == 'TIFF':
filename = filename_prefixe + map_doc_name + ".tif"
outfile = os.path.join(outputdirectory, filename)
# Export to JPEG optional parameters
data_frame = "PAGE_LAYOUT"
df_export_width = 640
df_export_height = 480
resolution = 96
world_file = False
color_mode = "24-BIT_TRUE_COLOR"
tiff_compression = "LZW"
# Run the export tool
arcpy.mapping.ExportToTIFF(mxd, outfile, data_frame,
df_export_width, df_export_height,
resolution, world_file, color_mode,
tiff_compression)
arcpy.AddMessage("TIFF is located: " + outfile)
return filename
elif export == "MAP PACKAGE":
filename = filename_prefixe + map_doc_name + ".mpk"
outfile = os.path.join(outputdirectory, filename)
dfextent = data_frame.extent
mxd = mxd.filePath
arcpy.AddMessage(mxd)
# Export to MPK optional parameters
convert_data = "CONVERT"
convert_arcsde_data = "CONVERT_ARCSDE"
apply_extent_to_arcsde = "ALL"
arcgisruntime = "DESKTOP"
reference_all_data = "NOT_REFERENCED"
version = "ALL"
# Run the export tool
arcpy.PackageMap_management(mxd, outfile, convert_data,
convert_arcsde_data, dfextent,
apply_extent_to_arcsde, arcgisruntime,
reference_all_data, version)
arcpy.AddMessage("MPK is located: " + outfile)
return filename
elif export == 'LAYOUT GEOTIFF':
filename = filename_prefixe + map_doc_name + ".tif"
outfile = os.path.join(outputdirectory, filename)
# Export to Layout GeoTIFF optional parameters:
resolution = 96
world_file = False
color_mode = "24-BIT_TRUE_COLOR"
tiff_compression = "LZW"
# Run the export tool
arcpyproduction.mapping.ExportToLayoutGeoTIFF(
mxd, outfile, data_frame, resolution, world_file, color_mode,
tiff_compression)
arcpy.AddMessage("Layout GeoTIFF is located: " + outfile)
return filename
elif export == 'PRODUCTION PDF' or export == 'MULTI-PAGE PDF':
filename = filename_prefixe + map_doc_name + ".pdf"
outfile = os.path.join(outputdirectory, filename)
setting_file = os.path.join(product_location, production_xml)
if os.path.exists(setting_file) == True:
arcpyproduction.mapping.ExportToProductionPDF(
mxd, outfile, setting_file)
arcpy.AddMessage("Production PDF is located: " + outfile)
else:
arcpy.AddMessage(
"Production PDF is the default exporter for a Multi-page PDF."
)
arcpy.AddWarning(
"Color mapping rules file doesn't exist, using "
"standard ExportToPDF exporter with default "
"settings.")
arcpy.mapping.ExportToPDF(mxd, outfile)
arcpy.AddMessage("PDF is located: " + outfile)
return filename
else:
arcpy.AddError("The exporter : " + export + " is not supported, "
"please contact your system administrator.")
except arcpy.ExecuteError:
arcpy.AddError(arcpy.GetMessages(2))
except Exception as ex:
arcpy.AddError(ex.message)
tb = sys.exc_info()[2]
tbinfo = traceback.format_tb(tb)[0]
arcpy.AddError("Traceback info:\n" + tbinfo)
def execute(request):
"""Package inputs to an Esri map or layer package.
:param request: json as a dict.
"""
errors = 0
skipped = 0
layers = []
files = []
app_folder = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
parameters = request['params']
out_format = task_utils.get_parameter_value(parameters, 'output_format',
'value')
summary = task_utils.get_parameter_value(parameters, 'summary')
tags = task_utils.get_parameter_value(parameters, 'tags')
output_file_name = task_utils.get_parameter_value(parameters,
'output_file_name')
if not output_file_name:
output_file_name = 'package_results'
# Get the clip region as an extent object.
clip_area = None
try:
clip_area_wkt = task_utils.get_parameter_value(parameters,
'processing_extent',
'wkt')
clip_area = task_utils.get_clip_region(clip_area_wkt)
except (KeyError, ValueError):
pass
out_workspace = os.path.join(request['folder'], 'temp')
if not os.path.exists(out_workspace):
os.makedirs(out_workspace)
num_results, response_index = task_utils.get_result_count(parameters)
# if num_results > task_utils.CHUNK_SIZE:
# Query the index for results in groups of 25.
query_index = task_utils.QueryIndex(parameters[response_index])
fl = query_index.fl
query = '{0}{1}{2}'.format(sys.argv[2].split('=')[1], '/select?&wt=json',
fl)
fq = query_index.get_fq()
if fq:
groups = task_utils.grouper(range(0, num_results),
task_utils.CHUNK_SIZE, '')
query += fq
elif 'ids' in parameters[response_index]:
groups = task_utils.grouper(list(parameters[response_index]['ids']),
task_utils.CHUNK_SIZE, '')
else:
groups = task_utils.grouper(range(0, num_results),
task_utils.CHUNK_SIZE, '')
headers = {
'x-access-token': task_utils.get_security_token(request['owner'])
}
status_writer.send_status(_('Starting to process...'))
for group in groups:
if fq:
results = requests.get(
query +
"&rows={0}&start={1}".format(task_utils.CHUNK_SIZE, group[0]),
verify=verify_ssl,
headers=headers)
elif 'ids' in parameters[response_index]:
results = requests.get(query +
'{0}&ids={1}'.format(fl, ','.join(group)),
verify=verify_ssl,
headers=headers)
else:
results = requests.get(
query +
"&rows={0}&start={1}".format(task_utils.CHUNK_SIZE, group[0]),
verify=verify_ssl,
headers=headers)
input_items = task_utils.get_input_items(
results.json()['response']['docs'])
if not input_items:
input_items = task_utils.get_input_items(
parameters[response_index]['response']['docs'])
layers, files, errors, skipped = get_items(input_items, out_workspace)
# else:
# input_items = task_utils.get_input_items(parameters[response_index]['response']['docs'])
# layers, files, errors, skipped = get_items(input_items, out_workspace)
if errors == num_results:
status_writer.send_state(status.STAT_FAILED,
_('No results to package'))
return
try:
if out_format == 'MPK':
shutil.copyfile(
os.path.join(app_folder, 'supportfiles', 'MapTemplate.mxd'),
os.path.join(out_workspace, 'output.mxd'))
mxd = arcpy.mapping.MapDocument(
os.path.join(out_workspace, 'output.mxd'))
if mxd.description == '':
mxd.description = os.path.basename(mxd.filePath)
df = arcpy.mapping.ListDataFrames(mxd)[0]
for layer in layers:
arcpy.mapping.AddLayer(df, layer)
mxd.save()
status_writer.send_status(
_('Generating {0}. Large input {1} will take longer to process.'
.format('MPK', 'results')))
if arcpy.GetInstallInfo()['Version'] == '10.0':
arcpy.PackageMap_management(
mxd.filePath,
os.path.join(os.path.dirname(out_workspace),
'{0}.mpk'.format(output_file_name)),
'PRESERVE',
extent=clip_area)
elif arcpy.GetInstallInfo()['Version'] == '10.1':
arcpy.PackageMap_management(
mxd.filePath,
os.path.join(os.path.dirname(out_workspace),
'{0}.mpk'.format(output_file_name)),
'PRESERVE',
extent=clip_area,
ArcGISRuntime='RUNTIME',
version='10',
additional_files=files,
summary=summary,
tags=tags)
else:
arcpy.PackageMap_management(
mxd.filePath,
os.path.join(os.path.dirname(out_workspace),
'{0}.mpk'.format(output_file_name)),
'PRESERVE',
extent=clip_area,
arcgisruntime='RUNTIME',
version='10',
additional_files=files,
summary=summary,
tags=tags)
# Create a thumbnail size PNG of the mxd.
task_utils.make_thumbnail(
mxd, os.path.join(request['folder'], '_thumb.png'))
else:
status_writer.send_status(
_('Generating {0}. Large input {1} will take longer to process.'
.format('LPK', 'results')))
for layer in layers:
if layer.description == '':
layer.description = layer.name
if arcpy.GetInstallInfo()['Version'] == '10.0':
arcpy.PackageLayer_management(
layers,
os.path.join(os.path.dirname(out_workspace),
'{0}.lpk'.format(output_file_name)),
'PRESERVE',
extent=clip_area,
version='10')
else:
arcpy.PackageLayer_management(
layers,
os.path.join(os.path.dirname(out_workspace),
'{0}.lpk'.format(output_file_name)),
'PRESERVE',
extent=clip_area,
version='10',
additional_files=files,
summary=summary,
tags=tags)
# Create a thumbnail size PNG of the mxd.
task_utils.make_thumbnail(
layers[0], os.path.join(request['folder'], '_thumb.png'))
except (RuntimeError, ValueError, arcpy.ExecuteError) as ex:
status_writer.send_state(status.STAT_FAILED, repr(ex))
return
# Update state if necessary.
if errors > 0 or skipped:
status_writer.send_state(
status.STAT_WARNING,
_('{0} results could not be processed').format(errors + skipped))
task_utils.report(os.path.join(request['folder'], '__report.json'),
num_results - (skipped + errors), skipped, errors,
errors_reasons, skipped_reasons)
addCommentsToFc(existingFc, "esriGeometryPolyline",
"redline-graphicslayer", "remarks")
elif layer.name == "polygonLayer":
addCommentsToFc(existingFc, "esriGeometryPolygon",
"redline-graphicslayer", "remarks")
# package map doc
# tool requires doc to have a description
generatedMapDoc = mapping.MapDocument(generatedMxdFilePath)
generatedMapDoc.description = "Auckland Council web viewer export graphics map document"
generatedMapDoc.save()
log("Packaging map: " + generatedMxdFilePath)
log("Saving to: " + outMpk)
arcpy.PackageMap_management(generatedMxdFilePath, outMpk, "CONVERT",
"CONVERT_ARCSDE", "#", "ALL", "DESKTOP",
"NOT_REFERENCED", "10.1",
[outWebmapTextFilePath])
# supply location to client
resultObj["url"] = outMpkUrl
# shapefiles need generating from gp service
if inputFileId:
# unzip uploaded files
uploadPathRoot = path.join(serverUploadPath, inputFileId)
if not path.isdir(uploadPathRoot):
raise Exception("Upload directory not found: " + uploadPathRoot)
# find a map package in uploads
import arcpy, os, sys
mxd_path = r'D:\BCASProjects\CREL\Co-Management\CWS\CWS_a4.mxd'
Map_title = "Chunati WS Total Forest Loss (2001-2012)"
mpk_path = r'D:\Database\CREL_Database\CREL_DATABASE\Satchari_National_Park\MPKs'
full_mpk_path = os.path.join(mpk_path, Map_title + '_Hansen_Analysis')
mxd = arcpy.mapping.MapDocument('CURRENT')
mxd.title = Map_title
mxd.summary = "These data is generated from Rapid Eye (2013-2014) and Landsat images are used"
mxd.description = "This map is produced after an analysis of Hansen data and RapidEye images to track the land cover change over 12 years (2001-20012) in the CREL sites."
mxd.author = "CREL"
mxd.credits = "CREL,BCAS"
mxd.tags = "Hansen,Landcover Change"
mxd.hyperlinkBase = mxd_path.split("'")[0]
mxd.relativePaths = 'True'
arcpy.RefreshTOC()
arcpy.PackageMap_management(mxd_path, full_mpk_path + '.mpk', "CONVERT",
"PRESERVE_ARCSDE", "DISPLAY", "ALL", "DESKTOP",
"NOT_REFERENCED", "ALL")
arcpy.AddMessage('Writing report to ' + reportPath)
# start writing report text to a string variable
reportText = 'Title: ' + mxd.title + '\n'
reportText += 'Author: ' + mxd.author + '\n'
reportText += 'Description: ' + mxd.description + '\n'
reportText += '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' + '\n'
# if the user chose to do so, create map package
if packageMap:
packagePath = outDir + '\\' + mxd.title.replace('.', '_') + '.mpk'
if (os.path.exists(packagePath)):
arcpy.AddMessage('Map package already exists (' + packagePath + ')')
else:
arcpy.AddMessage('Creating map package (' + packagePath + ')')
arcpy.PackageMap_management(mxd.filePath, packagePath)
# loop thru all data frames in the map
dataFrames = mapping.ListDataFrames(mxd, '')
for frame in dataFrames:
# report data frame name and spatial reference
reportText += '\nData Frame: ' + frame.name + '\n'
reportText += 'Spatial Reference: ' + frame.spatialReference.name + '\n'
# get all layers in this data frame
layers = mapping.ListLayers(mxd, '', frame)
i = 0 # layer index position
# loop thru all layers in the data frame
for lyr in layers:
# report index position and name
reportText += '\tLayer ' + str(i) + ': ' + lyr.name + '\n'
i += 1 # same as i = i + 1