You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
171 lines
5.4 KiB
171 lines
5.4 KiB
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright 2014 Google Inc. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
"""Simple command-line sample for Google Maps Engine.
|
|
|
|
This sample code demonstrates use of the Google Maps Engine API. For more
|
|
information on the API, see developers.google.com/maps-engine/documentation/
|
|
|
|
These samples allow you to
|
|
1) List projects you have access to
|
|
2) List tables in a given project.
|
|
3) Upload a shapefile to create a Table asset.
|
|
|
|
Usage:
|
|
$ python maps_engine.py [-p project_id] [-s shapefile]
|
|
|
|
If you do not enter a shapefile, it will upload the included "polygons".
|
|
|
|
You can also get help on all the command-line flags the program understands
|
|
by running:
|
|
|
|
$ python maps_engine.py --help
|
|
|
|
To get detailed log output run:
|
|
|
|
$ python maps_engine.py -p 123456 --logging_level=DEBUG
|
|
"""
|
|
|
|
__author__ = "jlivni@google.com (Josh Livni)"
|
|
|
|
import argparse
|
|
import json
|
|
import logging
|
|
import sys
|
|
import time
|
|
|
|
from googleapiclient import sample_tools
|
|
from googleapiclient.http import MediaFileUpload
|
|
|
|
logging.basicConfig(level=logging.INFO)
|
|
|
|
# Declare command-line flags.
|
|
argparser = argparse.ArgumentParser(add_help=False)
|
|
argparser.add_argument("-p", "--project_id", help="optional GME Project ID")
|
|
argparser.add_argument("-s", "--shapefile", help="Shapefile (without the .shp)")
|
|
|
|
SUCCESSFUL_STATUS = ["processed", "complete", "ready"]
|
|
|
|
|
|
class MapsEngineSampleException(Exception):
|
|
"""Catch this for failures specific to this sample code."""
|
|
|
|
|
|
def ListProjects(service):
|
|
"""List the projects available to the authorized account.
|
|
|
|
Args:
|
|
service: The service object built by the Google API Python client library.
|
|
"""
|
|
projects = service.projects().list().execute()
|
|
logging.info(json.dumps(projects, indent=2))
|
|
|
|
|
|
def ListTables(service, project_id):
|
|
"""List the tables in a given project.
|
|
|
|
Args:
|
|
service: The service object built by the Google API Python client library.
|
|
project_id: string, id of the GME project.
|
|
"""
|
|
|
|
tables = service.tables().list(projectId=project_id).execute()
|
|
logging.info(json.dumps(tables, indent=2))
|
|
|
|
|
|
def UploadShapefile(service, project_id, shapefile_prefix):
|
|
"""Upload a shapefile to a given project, and display status when complete.
|
|
|
|
Args:
|
|
service: The service object built by the Google API Python client library.
|
|
project_id: string, id of the GME project.
|
|
shapefile_prefix: string, the shapefile without the .shp suffix.
|
|
|
|
Returns:
|
|
String id of the table asset.
|
|
"""
|
|
# A shapefile is actually a bunch of files; GME requires these four suffixes.
|
|
suffixes = ["shp", "dbf", "prj", "shx"]
|
|
files = []
|
|
for suffix in suffixes:
|
|
files.append({
|
|
"filename": "%s.%s" % (shapefile_prefix, suffix)
|
|
})
|
|
metadata = {
|
|
"projectId": project_id,
|
|
"name": shapefile_prefix,
|
|
"description": "polygons that were uploaded by a script",
|
|
"files": files,
|
|
# You need the string value of a valid shared and published ACL
|
|
# Check the "Access Lists" section of the Maps Engine UI for a list.
|
|
"draftAccessList": "Map Editors",
|
|
"tags": [shapefile_prefix, "auto_upload", "kittens"]
|
|
}
|
|
|
|
logging.info("Uploading metadata for %s", shapefile_prefix)
|
|
response = service.tables().upload(body=metadata).execute()
|
|
# We have now created an empty asset.
|
|
table_id = response["id"]
|
|
|
|
# And now upload each of the files individually, passing in the table id.
|
|
for suffix in suffixes:
|
|
shapefile = "%s.%s" % (shapefile_prefix, suffix)
|
|
media_body = MediaFileUpload(shapefile, mimetype="application/octet-stream")
|
|
logging.info("uploading %s", shapefile)
|
|
|
|
response = service.tables().files().insert(
|
|
id=table_id,
|
|
filename=shapefile,
|
|
media_body=media_body).execute()
|
|
|
|
# With all files uploaded, check status of the asset to ensure it's processed.
|
|
CheckAssetStatus(service, "tables", table_id)
|
|
return table_id
|
|
|
|
|
|
def CheckAssetStatus(service, asset_type, asset_id):
|
|
endpoint = getattr(service, asset_type)
|
|
response = endpoint().get(id=asset_id).execute()
|
|
status = response["processingStatus"]
|
|
logging.info("Asset Status: %s", status)
|
|
if status in SUCCESSFUL_STATUS:
|
|
logging.info("asset successfully processed; the id is %s", asset_id)
|
|
else:
|
|
logging.info("Asset %s; will check again in 5 seconds", status)
|
|
time.sleep(5)
|
|
CheckAssetStatus(service, asset_type, asset_id)
|
|
|
|
|
|
def main(argv):
|
|
# Authenticate and construct service.
|
|
service, flags = sample_tools.init(
|
|
argv, "mapsengine", "v1", __doc__, __file__, parents=[argparser],
|
|
scope="https://www.googleapis.com/auth/mapsengine")
|
|
|
|
if flags.project_id:
|
|
# ListTables(service, flags.project_id)
|
|
# The example polygons shapefile should be in this directory.
|
|
filename = flags.shapefile or "polygons"
|
|
table_id = UploadShapefile(service, flags.project_id, filename)
|
|
logging.info("Sucessfully created table: %s", table_id)
|
|
else:
|
|
ListProjects(service)
|
|
return
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main(sys.argv)
|