#!/usr/bin/env python
"""CLI for fusiontables, version v1."""
# NOTE: This file is autogenerated and should not be edited by hand.
import code
import os
import platform
import sys
from apitools.base.protorpclite import message_types
from apitools.base.protorpclite import messages
from google.apputils import appcommands
import gflags as flags
import apitools.base.py as apitools_base
from apitools.base.py import cli as apitools_base_cli
import fusiontables_v1_client as client_lib
import fusiontables_v1_messages as messages
def _DeclareFusiontablesFlags():
"""Declare global flags in an idempotent way."""
if 'api_endpoint' in flags.FLAGS:
return
flags.DEFINE_string(
'api_endpoint',
u'https://www.googleapis.com/fusiontables/v1/',
'URL of the API endpoint to use.',
short_name='fusiontables_url')
flags.DEFINE_string(
'history_file',
u'~/.fusiontables.v1.history',
'File with interactive shell history.')
flags.DEFINE_multistring(
'add_header', [],
'Additional http headers (as key=value strings). '
'Can be specified multiple times.')
flags.DEFINE_string(
'service_account_json_keyfile', '',
'Filename for a JSON service account key downloaded'
' from the Developer Console.')
flags.DEFINE_enum(
'alt',
u'json',
[u'csv', u'json'],
u'Data format for the response.')
flags.DEFINE_string(
'fields',
None,
u'Selector specifying which fields to include in a partial response.')
flags.DEFINE_string(
'key',
None,
u'API key. Your API key identifies your project and provides you with '
u'API access, quota, and reports. Required unless you provide an OAuth '
u'2.0 token.')
flags.DEFINE_string(
'oauth_token',
None,
u'OAuth 2.0 token for the current user.')
flags.DEFINE_boolean(
'prettyPrint',
'True',
u'Returns response with indentations and line breaks.')
flags.DEFINE_string(
'quotaUser',
None,
u'Available to use for quota purposes for server-side applications. Can'
u' be any arbitrary string assigned to a user, but should not exceed 40'
u' characters. Overrides userIp if both are provided.')
flags.DEFINE_string(
'trace',
None,
'A tracing token of the form "token:<tokenid>" to include in api '
'requests.')
flags.DEFINE_string(
'userIp',
None,
u'IP address of the site where the request originates. Use this if you '
u'want to enforce per-user limits.')
FLAGS = flags.FLAGS
apitools_base_cli.DeclareBaseFlags()
_DeclareFusiontablesFlags()
def GetGlobalParamsFromFlags():
"""Return a StandardQueryParameters based on flags."""
result = messages.StandardQueryParameters()
if FLAGS['alt'].present:
result.alt = messages.StandardQueryParameters.AltValueValuesEnum(FLAGS.alt)
if FLAGS['fields'].present:
result.fields = FLAGS.fields.decode('utf8')
if FLAGS['key'].present:
result.key = FLAGS.key.decode('utf8')
if FLAGS['oauth_token'].present:
result.oauth_token = FLAGS.oauth_token.decode('utf8')
if FLAGS['prettyPrint'].present:
result.prettyPrint = FLAGS.prettyPrint
if FLAGS['quotaUser'].present:
result.quotaUser = FLAGS.quotaUser.decode('utf8')
if FLAGS['trace'].present:
result.trace = FLAGS.trace.decode('utf8')
if FLAGS['userIp'].present:
result.userIp = FLAGS.userIp.decode('utf8')
return result
def GetClientFromFlags():
"""Return a client object, configured from flags."""
log_request = FLAGS.log_request or FLAGS.log_request_response
log_response = FLAGS.log_response or FLAGS.log_request_response
api_endpoint = apitools_base.NormalizeApiEndpoint(FLAGS.api_endpoint)
additional_http_headers = dict(x.split('=', 1) for x in FLAGS.add_header)
credentials_args = {
'service_account_json_keyfile': os.path.expanduser(FLAGS.service_account_json_keyfile)
}
try:
client = client_lib.FusiontablesV1(
api_endpoint, log_request=log_request,
log_response=log_response,
credentials_args=credentials_args,
additional_http_headers=additional_http_headers)
except apitools_base.CredentialsError as e:
print 'Error creating credentials: %s' % e
sys.exit(1)
return client
class PyShell(appcommands.Cmd):
def Run(self, _):
"""Run an interactive python shell with the client."""
client = GetClientFromFlags()
params = GetGlobalParamsFromFlags()
for field in params.all_fields():
value = params.get_assigned_value(field.name)
if value != field.default:
client.AddGlobalParam(field.name, value)
banner = """
== fusiontables interactive console ==
client: a fusiontables client
apitools_base: base apitools module
messages: the generated messages module
"""
local_vars = {
'apitools_base': apitools_base,
'client': client,
'client_lib': client_lib,
'messages': messages,
}
if platform.system() == 'Linux':
console = apitools_base_cli.ConsoleWithReadline(
local_vars, histfile=FLAGS.history_file)
else:
console = code.InteractiveConsole(local_vars)
try:
console.interact(banner)
except SystemExit as e:
return e.code
class ColumnDelete(apitools_base_cli.NewCmd):
"""Command wrapping column.Delete."""
usage = """column_delete <tableId> <columnId>"""
def __init__(self, name, fv):
super(ColumnDelete, self).__init__(name, fv)
def RunWithArgs(self, tableId, columnId):
"""Deletes the column.
Args:
tableId: Table from which the column is being deleted.
columnId: Name or identifier for the column being deleted.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesColumnDeleteRequest(
tableId=tableId.decode('utf8'),
columnId=columnId.decode('utf8'),
)
result = client.column.Delete(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class ColumnGet(apitools_base_cli.NewCmd):
"""Command wrapping column.Get."""
usage = """column_get <tableId> <columnId>"""
def __init__(self, name, fv):
super(ColumnGet, self).__init__(name, fv)
def RunWithArgs(self, tableId, columnId):
"""Retrieves a specific column by its id.
Args:
tableId: Table to which the column belongs.
columnId: Name or identifier for the column that is being requested.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesColumnGetRequest(
tableId=tableId.decode('utf8'),
columnId=columnId.decode('utf8'),
)
result = client.column.Get(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class ColumnInsert(apitools_base_cli.NewCmd):
"""Command wrapping column.Insert."""
usage = """column_insert <tableId>"""
def __init__(self, name, fv):
super(ColumnInsert, self).__init__(name, fv)
flags.DEFINE_string(
'column',
None,
u'A Column resource to be passed as the request body.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Adds a new column to the table.
Args:
tableId: Table for which a new column is being added.
Flags:
column: A Column resource to be passed as the request body.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesColumnInsertRequest(
tableId=tableId.decode('utf8'),
)
if FLAGS['column'].present:
request.column = apitools_base.JsonToMessage(messages.Column, FLAGS.column)
result = client.column.Insert(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class ColumnList(apitools_base_cli.NewCmd):
"""Command wrapping column.List."""
usage = """column_list <tableId>"""
def __init__(self, name, fv):
super(ColumnList, self).__init__(name, fv)
flags.DEFINE_integer(
'maxResults',
None,
u'Maximum number of columns to return. Optional. Default is 5.',
flag_values=fv)
flags.DEFINE_string(
'pageToken',
None,
u'Continuation token specifying which result page to return. '
u'Optional.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Retrieves a list of columns.
Args:
tableId: Table whose columns are being listed.
Flags:
maxResults: Maximum number of columns to return. Optional. Default is 5.
pageToken: Continuation token specifying which result page to return.
Optional.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesColumnListRequest(
tableId=tableId.decode('utf8'),
)
if FLAGS['maxResults'].present:
request.maxResults = FLAGS.maxResults
if FLAGS['pageToken'].present:
request.pageToken = FLAGS.pageToken.decode('utf8')
result = client.column.List(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class ColumnPatch(apitools_base_cli.NewCmd):
"""Command wrapping column.Patch."""
usage = """column_patch <tableId> <columnId>"""
def __init__(self, name, fv):
super(ColumnPatch, self).__init__(name, fv)
flags.DEFINE_string(
'column',
None,
u'A Column resource to be passed as the request body.',
flag_values=fv)
def RunWithArgs(self, tableId, columnId):
"""Updates the name or type of an existing column. This method supports
patch semantics.
Args:
tableId: Table for which the column is being updated.
columnId: Name or identifier for the column that is being updated.
Flags:
column: A Column resource to be passed as the request body.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesColumnPatchRequest(
tableId=tableId.decode('utf8'),
columnId=columnId.decode('utf8'),
)
if FLAGS['column'].present:
request.column = apitools_base.JsonToMessage(messages.Column, FLAGS.column)
result = client.column.Patch(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class ColumnUpdate(apitools_base_cli.NewCmd):
"""Command wrapping column.Update."""
usage = """column_update <tableId> <columnId>"""
def __init__(self, name, fv):
super(ColumnUpdate, self).__init__(name, fv)
flags.DEFINE_string(
'column',
None,
u'A Column resource to be passed as the request body.',
flag_values=fv)
def RunWithArgs(self, tableId, columnId):
"""Updates the name or type of an existing column.
Args:
tableId: Table for which the column is being updated.
columnId: Name or identifier for the column that is being updated.
Flags:
column: A Column resource to be passed as the request body.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesColumnUpdateRequest(
tableId=tableId.decode('utf8'),
columnId=columnId.decode('utf8'),
)
if FLAGS['column'].present:
request.column = apitools_base.JsonToMessage(messages.Column, FLAGS.column)
result = client.column.Update(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class QuerySql(apitools_base_cli.NewCmd):
"""Command wrapping query.Sql."""
usage = """query_sql <sql>"""
def __init__(self, name, fv):
super(QuerySql, self).__init__(name, fv)
flags.DEFINE_boolean(
'hdrs',
None,
u'Should column names be included (in the first row)?. Default is '
u'true.',
flag_values=fv)
flags.DEFINE_boolean(
'typed',
None,
u'Should typed values be returned in the (JSON) response -- numbers '
u'for numeric values and parsed geometries for KML values? Default is'
u' true.',
flag_values=fv)
flags.DEFINE_string(
'download_filename',
'',
'Filename to use for download.',
flag_values=fv)
flags.DEFINE_boolean(
'overwrite',
'False',
'If True, overwrite the existing file when downloading.',
flag_values=fv)
def RunWithArgs(self, sql):
"""Executes an SQL SELECT/INSERT/UPDATE/DELETE/SHOW/DESCRIBE/CREATE
statement.
Args:
sql: An SQL SELECT/SHOW/DESCRIBE/INSERT/UPDATE/DELETE/CREATE statement.
Flags:
hdrs: Should column names be included (in the first row)?. Default is
true.
typed: Should typed values be returned in the (JSON) response -- numbers
for numeric values and parsed geometries for KML values? Default is
true.
download_filename: Filename to use for download.
overwrite: If True, overwrite the existing file when downloading.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesQuerySqlRequest(
sql=sql.decode('utf8'),
)
if FLAGS['hdrs'].present:
request.hdrs = FLAGS.hdrs
if FLAGS['typed'].present:
request.typed = FLAGS.typed
download = None
if FLAGS.download_filename:
download = apitools_base.Download.FromFile(FLAGS.download_filename, overwrite=FLAGS.overwrite,
progress_callback=apitools_base.DownloadProgressPrinter,
finish_callback=apitools_base.DownloadCompletePrinter)
result = client.query.Sql(
request, global_params=global_params, download=download)
print apitools_base_cli.FormatOutput(result)
class QuerySqlGet(apitools_base_cli.NewCmd):
"""Command wrapping query.SqlGet."""
usage = """query_sqlGet <sql>"""
def __init__(self, name, fv):
super(QuerySqlGet, self).__init__(name, fv)
flags.DEFINE_boolean(
'hdrs',
None,
u'Should column names be included (in the first row)?. Default is '
u'true.',
flag_values=fv)
flags.DEFINE_boolean(
'typed',
None,
u'Should typed values be returned in the (JSON) response -- numbers '
u'for numeric values and parsed geometries for KML values? Default is'
u' true.',
flag_values=fv)
flags.DEFINE_string(
'download_filename',
'',
'Filename to use for download.',
flag_values=fv)
flags.DEFINE_boolean(
'overwrite',
'False',
'If True, overwrite the existing file when downloading.',
flag_values=fv)
def RunWithArgs(self, sql):
"""Executes an SQL SELECT/SHOW/DESCRIBE statement.
Args:
sql: An SQL SELECT/SHOW/DESCRIBE statement.
Flags:
hdrs: Should column names be included (in the first row)?. Default is
true.
typed: Should typed values be returned in the (JSON) response -- numbers
for numeric values and parsed geometries for KML values? Default is
true.
download_filename: Filename to use for download.
overwrite: If True, overwrite the existing file when downloading.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesQuerySqlGetRequest(
sql=sql.decode('utf8'),
)
if FLAGS['hdrs'].present:
request.hdrs = FLAGS.hdrs
if FLAGS['typed'].present:
request.typed = FLAGS.typed
download = None
if FLAGS.download_filename:
download = apitools_base.Download.FromFile(FLAGS.download_filename, overwrite=FLAGS.overwrite,
progress_callback=apitools_base.DownloadProgressPrinter,
finish_callback=apitools_base.DownloadCompletePrinter)
result = client.query.SqlGet(
request, global_params=global_params, download=download)
print apitools_base_cli.FormatOutput(result)
class StyleDelete(apitools_base_cli.NewCmd):
"""Command wrapping style.Delete."""
usage = """style_delete <tableId> <styleId>"""
def __init__(self, name, fv):
super(StyleDelete, self).__init__(name, fv)
def RunWithArgs(self, tableId, styleId):
"""Deletes a style.
Args:
tableId: Table from which the style is being deleted
styleId: Identifier (within a table) for the style being deleted
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesStyleDeleteRequest(
tableId=tableId.decode('utf8'),
styleId=styleId,
)
result = client.style.Delete(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class StyleGet(apitools_base_cli.NewCmd):
"""Command wrapping style.Get."""
usage = """style_get <tableId> <styleId>"""
def __init__(self, name, fv):
super(StyleGet, self).__init__(name, fv)
def RunWithArgs(self, tableId, styleId):
"""Gets a specific style.
Args:
tableId: Table to which the requested style belongs
styleId: Identifier (integer) for a specific style in a table
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesStyleGetRequest(
tableId=tableId.decode('utf8'),
styleId=styleId,
)
result = client.style.Get(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class StyleInsert(apitools_base_cli.NewCmd):
"""Command wrapping style.Insert."""
usage = """style_insert <tableId>"""
def __init__(self, name, fv):
super(StyleInsert, self).__init__(name, fv)
flags.DEFINE_string(
'kind',
u'fusiontables#styleSetting',
u'Type name: an individual style setting. A StyleSetting contains the'
u' style defintions for points, lines, and polygons in a table. Since'
u' a table can have any one or all of them, a style definition can '
u'have point, line and polygon style definitions.',
flag_values=fv)
flags.DEFINE_string(
'markerOptions',
None,
u'Style definition for points in the table.',
flag_values=fv)
flags.DEFINE_string(
'name',
None,
u'Optional name for the style setting.',
flag_values=fv)
flags.DEFINE_string(
'polygonOptions',
None,
u'Style definition for polygons in the table.',
flag_values=fv)
flags.DEFINE_string(
'polylineOptions',
None,
u'Style definition for lines in the table.',
flag_values=fv)
flags.DEFINE_integer(
'styleId',
None,
u'Identifier for the style setting (unique only within tables).',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Adds a new style for the table.
Args:
tableId: Identifier for the table.
Flags:
kind: Type name: an individual style setting. A StyleSetting contains
the style defintions for points, lines, and polygons in a table. Since
a table can have any one or all of them, a style definition can have
point, line and polygon style definitions.
markerOptions: Style definition for points in the table.
name: Optional name for the style setting.
polygonOptions: Style definition for polygons in the table.
polylineOptions: Style definition for lines in the table.
styleId: Identifier for the style setting (unique only within tables).
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.StyleSetting(
tableId=tableId.decode('utf8'),
)
if FLAGS['kind'].present:
request.kind = FLAGS.kind.decode('utf8')
if FLAGS['markerOptions'].present:
request.markerOptions = apitools_base.JsonToMessage(messages.PointStyle, FLAGS.markerOptions)
if FLAGS['name'].present:
request.name = FLAGS.name.decode('utf8')
if FLAGS['polygonOptions'].present:
request.polygonOptions = apitools_base.JsonToMessage(messages.PolygonStyle, FLAGS.polygonOptions)
if FLAGS['polylineOptions'].present:
request.polylineOptions = apitools_base.JsonToMessage(messages.LineStyle, FLAGS.polylineOptions)
if FLAGS['styleId'].present:
request.styleId = FLAGS.styleId
result = client.style.Insert(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class StyleList(apitools_base_cli.NewCmd):
"""Command wrapping style.List."""
usage = """style_list <tableId>"""
def __init__(self, name, fv):
super(StyleList, self).__init__(name, fv)
flags.DEFINE_integer(
'maxResults',
None,
u'Maximum number of styles to return. Optional. Default is 5.',
flag_values=fv)
flags.DEFINE_string(
'pageToken',
None,
u'Continuation token specifying which result page to return. '
u'Optional.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Retrieves a list of styles.
Args:
tableId: Table whose styles are being listed
Flags:
maxResults: Maximum number of styles to return. Optional. Default is 5.
pageToken: Continuation token specifying which result page to return.
Optional.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesStyleListRequest(
tableId=tableId.decode('utf8'),
)
if FLAGS['maxResults'].present:
request.maxResults = FLAGS.maxResults
if FLAGS['pageToken'].present:
request.pageToken = FLAGS.pageToken.decode('utf8')
result = client.style.List(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class StylePatch(apitools_base_cli.NewCmd):
"""Command wrapping style.Patch."""
usage = """style_patch <tableId> <styleId>"""
def __init__(self, name, fv):
super(StylePatch, self).__init__(name, fv)
flags.DEFINE_string(
'kind',
u'fusiontables#styleSetting',
u'Type name: an individual style setting. A StyleSetting contains the'
u' style defintions for points, lines, and polygons in a table. Since'
u' a table can have any one or all of them, a style definition can '
u'have point, line and polygon style definitions.',
flag_values=fv)
flags.DEFINE_string(
'markerOptions',
None,
u'Style definition for points in the table.',
flag_values=fv)
flags.DEFINE_string(
'name',
None,
u'Optional name for the style setting.',
flag_values=fv)
flags.DEFINE_string(
'polygonOptions',
None,
u'Style definition for polygons in the table.',
flag_values=fv)
flags.DEFINE_string(
'polylineOptions',
None,
u'Style definition for lines in the table.',
flag_values=fv)
def RunWithArgs(self, tableId, styleId):
"""Updates an existing style. This method supports patch semantics.
Args:
tableId: Identifier for the table.
styleId: Identifier for the style setting (unique only within tables).
Flags:
kind: Type name: an individual style setting. A StyleSetting contains
the style defintions for points, lines, and polygons in a table. Since
a table can have any one or all of them, a style definition can have
point, line and polygon style definitions.
markerOptions: Style definition for points in the table.
name: Optional name for the style setting.
polygonOptions: Style definition for polygons in the table.
polylineOptions: Style definition for lines in the table.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.StyleSetting(
tableId=tableId.decode('utf8'),
styleId=styleId,
)
if FLAGS['kind'].present:
request.kind = FLAGS.kind.decode('utf8')
if FLAGS['markerOptions'].present:
request.markerOptions = apitools_base.JsonToMessage(messages.PointStyle, FLAGS.markerOptions)
if FLAGS['name'].present:
request.name = FLAGS.name.decode('utf8')
if FLAGS['polygonOptions'].present:
request.polygonOptions = apitools_base.JsonToMessage(messages.PolygonStyle, FLAGS.polygonOptions)
if FLAGS['polylineOptions'].present:
request.polylineOptions = apitools_base.JsonToMessage(messages.LineStyle, FLAGS.polylineOptions)
result = client.style.Patch(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class StyleUpdate(apitools_base_cli.NewCmd):
"""Command wrapping style.Update."""
usage = """style_update <tableId> <styleId>"""
def __init__(self, name, fv):
super(StyleUpdate, self).__init__(name, fv)
flags.DEFINE_string(
'kind',
u'fusiontables#styleSetting',
u'Type name: an individual style setting. A StyleSetting contains the'
u' style defintions for points, lines, and polygons in a table. Since'
u' a table can have any one or all of them, a style definition can '
u'have point, line and polygon style definitions.',
flag_values=fv)
flags.DEFINE_string(
'markerOptions',
None,
u'Style definition for points in the table.',
flag_values=fv)
flags.DEFINE_string(
'name',
None,
u'Optional name for the style setting.',
flag_values=fv)
flags.DEFINE_string(
'polygonOptions',
None,
u'Style definition for polygons in the table.',
flag_values=fv)
flags.DEFINE_string(
'polylineOptions',
None,
u'Style definition for lines in the table.',
flag_values=fv)
def RunWithArgs(self, tableId, styleId):
"""Updates an existing style.
Args:
tableId: Identifier for the table.
styleId: Identifier for the style setting (unique only within tables).
Flags:
kind: Type name: an individual style setting. A StyleSetting contains
the style defintions for points, lines, and polygons in a table. Since
a table can have any one or all of them, a style definition can have
point, line and polygon style definitions.
markerOptions: Style definition for points in the table.
name: Optional name for the style setting.
polygonOptions: Style definition for polygons in the table.
polylineOptions: Style definition for lines in the table.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.StyleSetting(
tableId=tableId.decode('utf8'),
styleId=styleId,
)
if FLAGS['kind'].present:
request.kind = FLAGS.kind.decode('utf8')
if FLAGS['markerOptions'].present:
request.markerOptions = apitools_base.JsonToMessage(messages.PointStyle, FLAGS.markerOptions)
if FLAGS['name'].present:
request.name = FLAGS.name.decode('utf8')
if FLAGS['polygonOptions'].present:
request.polygonOptions = apitools_base.JsonToMessage(messages.PolygonStyle, FLAGS.polygonOptions)
if FLAGS['polylineOptions'].present:
request.polylineOptions = apitools_base.JsonToMessage(messages.LineStyle, FLAGS.polylineOptions)
result = client.style.Update(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TableCopy(apitools_base_cli.NewCmd):
"""Command wrapping table.Copy."""
usage = """table_copy <tableId>"""
def __init__(self, name, fv):
super(TableCopy, self).__init__(name, fv)
flags.DEFINE_boolean(
'copyPresentation',
None,
u'Whether to also copy tabs, styles, and templates. Default is false.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Copies a table.
Args:
tableId: ID of the table that is being copied.
Flags:
copyPresentation: Whether to also copy tabs, styles, and templates.
Default is false.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTableCopyRequest(
tableId=tableId.decode('utf8'),
)
if FLAGS['copyPresentation'].present:
request.copyPresentation = FLAGS.copyPresentation
result = client.table.Copy(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TableDelete(apitools_base_cli.NewCmd):
"""Command wrapping table.Delete."""
usage = """table_delete <tableId>"""
def __init__(self, name, fv):
super(TableDelete, self).__init__(name, fv)
def RunWithArgs(self, tableId):
"""Deletes a table.
Args:
tableId: ID of the table that is being deleted.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTableDeleteRequest(
tableId=tableId.decode('utf8'),
)
result = client.table.Delete(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TableGet(apitools_base_cli.NewCmd):
"""Command wrapping table.Get."""
usage = """table_get <tableId>"""
def __init__(self, name, fv):
super(TableGet, self).__init__(name, fv)
def RunWithArgs(self, tableId):
"""Retrieves a specific table by its id.
Args:
tableId: Identifier(ID) for the table being requested.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTableGetRequest(
tableId=tableId.decode('utf8'),
)
result = client.table.Get(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TableImportRows(apitools_base_cli.NewCmd):
"""Command wrapping table.ImportRows."""
usage = """table_importRows <tableId>"""
def __init__(self, name, fv):
super(TableImportRows, self).__init__(name, fv)
flags.DEFINE_string(
'delimiter',
None,
u'The delimiter used to separate cell values. This can only consist '
u"of a single character. Default is ','.",
flag_values=fv)
flags.DEFINE_string(
'encoding',
None,
u"The encoding of the content. Default is UTF-8. Use 'auto-detect' if"
u' you are unsure of the encoding.',
flag_values=fv)
flags.DEFINE_integer(
'endLine',
None,
u'The index of the last line from which to start importing, '
u'exclusive. Thus, the number of imported lines is endLine - '
u'startLine. If this parameter is not provided, the file will be '
u'imported until the last line of the file. If endLine is negative, '
u'then the imported content will exclude the last endLine lines. That'
u' is, if endline is negative, no line will be imported whose index '
u'is greater than N + endLine where N is the number of lines in the '
u'file, and the number of imported lines will be N + endLine - '
u'startLine.',
flag_values=fv)
flags.DEFINE_boolean(
'isStrict',
None,
u'Whether the CSV must have the same number of values for each row. '
u'If false, rows with fewer values will be padded with empty values. '
u'Default is true.',
flag_values=fv)
flags.DEFINE_integer(
'startLine',
None,
u'The index of the first line from which to start importing, '
u'inclusive. Default is 0.',
flag_values=fv)
flags.DEFINE_string(
'upload_filename',
'',
'Filename to use for upload.',
flag_values=fv)
flags.DEFINE_string(
'upload_mime_type',
'',
'MIME type to use for the upload. Only needed if the extension on '
'--upload_filename does not determine the correct (or any) MIME '
'type.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Import more rows into a table.
Args:
tableId: The table into which new rows are being imported.
Flags:
delimiter: The delimiter used to separate cell values. This can only
consist of a single character. Default is ','.
encoding: The encoding of the content. Default is UTF-8. Use 'auto-
detect' if you are unsure of the encoding.
endLine: The index of the last line from which to start importing,
exclusive. Thus, the number of imported lines is endLine - startLine.
If this parameter is not provided, the file will be imported until the
last line of the file. If endLine is negative, then the imported
content will exclude the last endLine lines. That is, if endline is
negative, no line will be imported whose index is greater than N +
endLine where N is the number of lines in the file, and the number of
imported lines will be N + endLine - startLine.
isStrict: Whether the CSV must have the same number of values for each
row. If false, rows with fewer values will be padded with empty
values. Default is true.
startLine: The index of the first line from which to start importing,
inclusive. Default is 0.
upload_filename: Filename to use for upload.
upload_mime_type: MIME type to use for the upload. Only needed if the
extension on --upload_filename does not determine the correct (or any)
MIME type.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTableImportRowsRequest(
tableId=tableId.decode('utf8'),
)
if FLAGS['delimiter'].present:
request.delimiter = FLAGS.delimiter.decode('utf8')
if FLAGS['encoding'].present:
request.encoding = FLAGS.encoding.decode('utf8')
if FLAGS['endLine'].present:
request.endLine = FLAGS.endLine
if FLAGS['isStrict'].present:
request.isStrict = FLAGS.isStrict
if FLAGS['startLine'].present:
request.startLine = FLAGS.startLine
upload = None
if FLAGS.upload_filename:
upload = apitools_base.Upload.FromFile(
FLAGS.upload_filename, FLAGS.upload_mime_type,
progress_callback=apitools_base.UploadProgressPrinter,
finish_callback=apitools_base.UploadCompletePrinter)
result = client.table.ImportRows(
request, global_params=global_params, upload=upload)
print apitools_base_cli.FormatOutput(result)
class TableImportTable(apitools_base_cli.NewCmd):
"""Command wrapping table.ImportTable."""
usage = """table_importTable <name>"""
def __init__(self, name, fv):
super(TableImportTable, self).__init__(name, fv)
flags.DEFINE_string(
'delimiter',
None,
u'The delimiter used to separate cell values. This can only consist '
u"of a single character. Default is ','.",
flag_values=fv)
flags.DEFINE_string(
'encoding',
None,
u"The encoding of the content. Default is UTF-8. Use 'auto-detect' if"
u' you are unsure of the encoding.',
flag_values=fv)
flags.DEFINE_string(
'upload_filename',
'',
'Filename to use for upload.',
flag_values=fv)
flags.DEFINE_string(
'upload_mime_type',
'',
'MIME type to use for the upload. Only needed if the extension on '
'--upload_filename does not determine the correct (or any) MIME '
'type.',
flag_values=fv)
def RunWithArgs(self, name):
"""Import a new table.
Args:
name: The name to be assigned to the new table.
Flags:
delimiter: The delimiter used to separate cell values. This can only
consist of a single character. Default is ','.
encoding: The encoding of the content. Default is UTF-8. Use 'auto-
detect' if you are unsure of the encoding.
upload_filename: Filename to use for upload.
upload_mime_type: MIME type to use for the upload. Only needed if the
extension on --upload_filename does not determine the correct (or any)
MIME type.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTableImportTableRequest(
name=name.decode('utf8'),
)
if FLAGS['delimiter'].present:
request.delimiter = FLAGS.delimiter.decode('utf8')
if FLAGS['encoding'].present:
request.encoding = FLAGS.encoding.decode('utf8')
upload = None
if FLAGS.upload_filename:
upload = apitools_base.Upload.FromFile(
FLAGS.upload_filename, FLAGS.upload_mime_type,
progress_callback=apitools_base.UploadProgressPrinter,
finish_callback=apitools_base.UploadCompletePrinter)
result = client.table.ImportTable(
request, global_params=global_params, upload=upload)
print apitools_base_cli.FormatOutput(result)
class TableInsert(apitools_base_cli.NewCmd):
"""Command wrapping table.Insert."""
usage = """table_insert"""
def __init__(self, name, fv):
super(TableInsert, self).__init__(name, fv)
flags.DEFINE_string(
'attribution',
None,
u'Optional attribution assigned to the table.',
flag_values=fv)
flags.DEFINE_string(
'attributionLink',
None,
u'Optional link for attribution.',
flag_values=fv)
flags.DEFINE_string(
'baseTableIds',
None,
u'Optional base table identifier if this table is a view or merged '
u'table.',
flag_values=fv)
flags.DEFINE_string(
'columns',
None,
u'Columns in the table.',
flag_values=fv)
flags.DEFINE_string(
'description',
None,
u'Optional description assigned to the table.',
flag_values=fv)
flags.DEFINE_boolean(
'isExportable',
None,
u'Variable for whether table is exportable.',
flag_values=fv)
flags.DEFINE_string(
'kind',
u'fusiontables#table',
u'Type name: a template for an individual table.',
flag_values=fv)
flags.DEFINE_string(
'name',
None,
u'Name assigned to a table.',
flag_values=fv)
flags.DEFINE_string(
'sql',
None,
u'Optional sql that encodes the table definition for derived tables.',
flag_values=fv)
flags.DEFINE_string(
'tableId',
None,
u'Encrypted unique alphanumeric identifier for the table.',
flag_values=fv)
def RunWithArgs(self):
"""Creates a new table.
Flags:
attribution: Optional attribution assigned to the table.
attributionLink: Optional link for attribution.
baseTableIds: Optional base table identifier if this table is a view or
merged table.
columns: Columns in the table.
description: Optional description assigned to the table.
isExportable: Variable for whether table is exportable.
kind: Type name: a template for an individual table.
name: Name assigned to a table.
sql: Optional sql that encodes the table definition for derived tables.
tableId: Encrypted unique alphanumeric identifier for the table.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.Table(
)
if FLAGS['attribution'].present:
request.attribution = FLAGS.attribution.decode('utf8')
if FLAGS['attributionLink'].present:
request.attributionLink = FLAGS.attributionLink.decode('utf8')
if FLAGS['baseTableIds'].present:
request.baseTableIds = [x.decode('utf8') for x in FLAGS.baseTableIds]
if FLAGS['columns'].present:
request.columns = [apitools_base.JsonToMessage(messages.Column, x) for x in FLAGS.columns]
if FLAGS['description'].present:
request.description = FLAGS.description.decode('utf8')
if FLAGS['isExportable'].present:
request.isExportable = FLAGS.isExportable
if FLAGS['kind'].present:
request.kind = FLAGS.kind.decode('utf8')
if FLAGS['name'].present:
request.name = FLAGS.name.decode('utf8')
if FLAGS['sql'].present:
request.sql = FLAGS.sql.decode('utf8')
if FLAGS['tableId'].present:
request.tableId = FLAGS.tableId.decode('utf8')
result = client.table.Insert(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TableList(apitools_base_cli.NewCmd):
"""Command wrapping table.List."""
usage = """table_list"""
def __init__(self, name, fv):
super(TableList, self).__init__(name, fv)
flags.DEFINE_integer(
'maxResults',
None,
u'Maximum number of styles to return. Optional. Default is 5.',
flag_values=fv)
flags.DEFINE_string(
'pageToken',
None,
u'Continuation token specifying which result page to return. '
u'Optional.',
flag_values=fv)
def RunWithArgs(self):
"""Retrieves a list of tables a user owns.
Flags:
maxResults: Maximum number of styles to return. Optional. Default is 5.
pageToken: Continuation token specifying which result page to return.
Optional.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTableListRequest(
)
if FLAGS['maxResults'].present:
request.maxResults = FLAGS.maxResults
if FLAGS['pageToken'].present:
request.pageToken = FLAGS.pageToken.decode('utf8')
result = client.table.List(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TablePatch(apitools_base_cli.NewCmd):
"""Command wrapping table.Patch."""
usage = """table_patch <tableId>"""
def __init__(self, name, fv):
super(TablePatch, self).__init__(name, fv)
flags.DEFINE_boolean(
'replaceViewDefinition',
None,
u'Should the view definition also be updated? The specified view '
u'definition replaces the existing one. Only a view can be updated '
u'with a new definition.',
flag_values=fv)
flags.DEFINE_string(
'table',
None,
u'A Table resource to be passed as the request body.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Updates an existing table. Unless explicitly requested, only the name,
description, and attribution will be updated. This method supports patch
semantics.
Args:
tableId: ID of the table that is being updated.
Flags:
replaceViewDefinition: Should the view definition also be updated? The
specified view definition replaces the existing one. Only a view can
be updated with a new definition.
table: A Table resource to be passed as the request body.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTablePatchRequest(
tableId=tableId.decode('utf8'),
)
if FLAGS['replaceViewDefinition'].present:
request.replaceViewDefinition = FLAGS.replaceViewDefinition
if FLAGS['table'].present:
request.table = apitools_base.JsonToMessage(messages.Table, FLAGS.table)
result = client.table.Patch(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TableUpdate(apitools_base_cli.NewCmd):
"""Command wrapping table.Update."""
usage = """table_update <tableId>"""
def __init__(self, name, fv):
super(TableUpdate, self).__init__(name, fv)
flags.DEFINE_boolean(
'replaceViewDefinition',
None,
u'Should the view definition also be updated? The specified view '
u'definition replaces the existing one. Only a view can be updated '
u'with a new definition.',
flag_values=fv)
flags.DEFINE_string(
'table',
None,
u'A Table resource to be passed as the request body.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Updates an existing table. Unless explicitly requested, only the name,
description, and attribution will be updated.
Args:
tableId: ID of the table that is being updated.
Flags:
replaceViewDefinition: Should the view definition also be updated? The
specified view definition replaces the existing one. Only a view can
be updated with a new definition.
table: A Table resource to be passed as the request body.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTableUpdateRequest(
tableId=tableId.decode('utf8'),
)
if FLAGS['replaceViewDefinition'].present:
request.replaceViewDefinition = FLAGS.replaceViewDefinition
if FLAGS['table'].present:
request.table = apitools_base.JsonToMessage(messages.Table, FLAGS.table)
result = client.table.Update(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TaskDelete(apitools_base_cli.NewCmd):
"""Command wrapping task.Delete."""
usage = """task_delete <tableId> <taskId>"""
def __init__(self, name, fv):
super(TaskDelete, self).__init__(name, fv)
def RunWithArgs(self, tableId, taskId):
"""Deletes the task, unless already started.
Args:
tableId: Table from which the task is being deleted.
taskId: A string attribute.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTaskDeleteRequest(
tableId=tableId.decode('utf8'),
taskId=taskId.decode('utf8'),
)
result = client.task.Delete(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TaskGet(apitools_base_cli.NewCmd):
"""Command wrapping task.Get."""
usage = """task_get <tableId> <taskId>"""
def __init__(self, name, fv):
super(TaskGet, self).__init__(name, fv)
def RunWithArgs(self, tableId, taskId):
"""Retrieves a specific task by its id.
Args:
tableId: Table to which the task belongs.
taskId: A string attribute.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTaskGetRequest(
tableId=tableId.decode('utf8'),
taskId=taskId.decode('utf8'),
)
result = client.task.Get(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TaskList(apitools_base_cli.NewCmd):
"""Command wrapping task.List."""
usage = """task_list <tableId>"""
def __init__(self, name, fv):
super(TaskList, self).__init__(name, fv)
flags.DEFINE_integer(
'maxResults',
None,
u'Maximum number of columns to return. Optional. Default is 5.',
flag_values=fv)
flags.DEFINE_string(
'pageToken',
None,
'A string attribute.',
flag_values=fv)
flags.DEFINE_integer(
'startIndex',
None,
'A integer attribute.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Retrieves a list of tasks.
Args:
tableId: Table whose tasks are being listed.
Flags:
maxResults: Maximum number of columns to return. Optional. Default is 5.
pageToken: A string attribute.
startIndex: A integer attribute.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTaskListRequest(
tableId=tableId.decode('utf8'),
)
if FLAGS['maxResults'].present:
request.maxResults = FLAGS.maxResults
if FLAGS['pageToken'].present:
request.pageToken = FLAGS.pageToken.decode('utf8')
if FLAGS['startIndex'].present:
request.startIndex = FLAGS.startIndex
result = client.task.List(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TemplateDelete(apitools_base_cli.NewCmd):
"""Command wrapping template.Delete."""
usage = """template_delete <tableId> <templateId>"""
def __init__(self, name, fv):
super(TemplateDelete, self).__init__(name, fv)
def RunWithArgs(self, tableId, templateId):
"""Deletes a template
Args:
tableId: Table from which the template is being deleted
templateId: Identifier for the template which is being deleted
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTemplateDeleteRequest(
tableId=tableId.decode('utf8'),
templateId=templateId,
)
result = client.template.Delete(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TemplateGet(apitools_base_cli.NewCmd):
"""Command wrapping template.Get."""
usage = """template_get <tableId> <templateId>"""
def __init__(self, name, fv):
super(TemplateGet, self).__init__(name, fv)
def RunWithArgs(self, tableId, templateId):
"""Retrieves a specific template by its id
Args:
tableId: Table to which the template belongs
templateId: Identifier for the template that is being requested
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTemplateGetRequest(
tableId=tableId.decode('utf8'),
templateId=templateId,
)
result = client.template.Get(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TemplateInsert(apitools_base_cli.NewCmd):
"""Command wrapping template.Insert."""
usage = """template_insert <tableId>"""
def __init__(self, name, fv):
super(TemplateInsert, self).__init__(name, fv)
flags.DEFINE_string(
'automaticColumnNames',
None,
u'List of columns from which the template is to be automatically '
u'constructed. Only one of body or automaticColumns can be specified.',
flag_values=fv)
flags.DEFINE_string(
'body',
None,
u'Body of the template. It contains HTML with {column_name} to insert'
u' values from a particular column. The body is sanitized to remove '
u'certain tags, e.g., script. Only one of body or automaticColumns '
u'can be specified.',
flag_values=fv)
flags.DEFINE_string(
'kind',
u'fusiontables#template',
u'Type name: a template for the info window contents. The template '
u'can either include an HTML body or a list of columns from which the'
u' template is computed automatically.',
flag_values=fv)
flags.DEFINE_string(
'name',
None,
u'Optional name assigned to a template.',
flag_values=fv)
flags.DEFINE_integer(
'templateId',
None,
u'Identifier for the template, unique within the context of a '
u'particular table.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Creates a new template for the table.
Args:
tableId: Identifier for the table for which the template is defined.
Flags:
automaticColumnNames: List of columns from which the template is to be
automatically constructed. Only one of body or automaticColumns can be
specified.
body: Body of the template. It contains HTML with {column_name} to
insert values from a particular column. The body is sanitized to
remove certain tags, e.g., script. Only one of body or
automaticColumns can be specified.
kind: Type name: a template for the info window contents. The template
can either include an HTML body or a list of columns from which the
template is computed automatically.
name: Optional name assigned to a template.
templateId: Identifier for the template, unique within the context of a
particular table.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.Template(
tableId=tableId.decode('utf8'),
)
if FLAGS['automaticColumnNames'].present:
request.automaticColumnNames = [x.decode('utf8') for x in FLAGS.automaticColumnNames]
if FLAGS['body'].present:
request.body = FLAGS.body.decode('utf8')
if FLAGS['kind'].present:
request.kind = FLAGS.kind.decode('utf8')
if FLAGS['name'].present:
request.name = FLAGS.name.decode('utf8')
if FLAGS['templateId'].present:
request.templateId = FLAGS.templateId
result = client.template.Insert(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TemplateList(apitools_base_cli.NewCmd):
"""Command wrapping template.List."""
usage = """template_list <tableId>"""
def __init__(self, name, fv):
super(TemplateList, self).__init__(name, fv)
flags.DEFINE_integer(
'maxResults',
None,
u'Maximum number of templates to return. Optional. Default is 5.',
flag_values=fv)
flags.DEFINE_string(
'pageToken',
None,
u'Continuation token specifying which results page to return. '
u'Optional.',
flag_values=fv)
def RunWithArgs(self, tableId):
"""Retrieves a list of templates.
Args:
tableId: Identifier for the table whose templates are being requested
Flags:
maxResults: Maximum number of templates to return. Optional. Default is
5.
pageToken: Continuation token specifying which results page to return.
Optional.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.FusiontablesTemplateListRequest(
tableId=tableId.decode('utf8'),
)
if FLAGS['maxResults'].present:
request.maxResults = FLAGS.maxResults
if FLAGS['pageToken'].present:
request.pageToken = FLAGS.pageToken.decode('utf8')
result = client.template.List(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TemplatePatch(apitools_base_cli.NewCmd):
"""Command wrapping template.Patch."""
usage = """template_patch <tableId> <templateId>"""
def __init__(self, name, fv):
super(TemplatePatch, self).__init__(name, fv)
flags.DEFINE_string(
'automaticColumnNames',
None,
u'List of columns from which the template is to be automatically '
u'constructed. Only one of body or automaticColumns can be specified.',
flag_values=fv)
flags.DEFINE_string(
'body',
None,
u'Body of the template. It contains HTML with {column_name} to insert'
u' values from a particular column. The body is sanitized to remove '
u'certain tags, e.g., script. Only one of body or automaticColumns '
u'can be specified.',
flag_values=fv)
flags.DEFINE_string(
'kind',
u'fusiontables#template',
u'Type name: a template for the info window contents. The template '
u'can either include an HTML body or a list of columns from which the'
u' template is computed automatically.',
flag_values=fv)
flags.DEFINE_string(
'name',
None,
u'Optional name assigned to a template.',
flag_values=fv)
def RunWithArgs(self, tableId, templateId):
"""Updates an existing template. This method supports patch semantics.
Args:
tableId: Identifier for the table for which the template is defined.
templateId: Identifier for the template, unique within the context of a
particular table.
Flags:
automaticColumnNames: List of columns from which the template is to be
automatically constructed. Only one of body or automaticColumns can be
specified.
body: Body of the template. It contains HTML with {column_name} to
insert values from a particular column. The body is sanitized to
remove certain tags, e.g., script. Only one of body or
automaticColumns can be specified.
kind: Type name: a template for the info window contents. The template
can either include an HTML body or a list of columns from which the
template is computed automatically.
name: Optional name assigned to a template.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.Template(
tableId=tableId.decode('utf8'),
templateId=templateId,
)
if FLAGS['automaticColumnNames'].present:
request.automaticColumnNames = [x.decode('utf8') for x in FLAGS.automaticColumnNames]
if FLAGS['body'].present:
request.body = FLAGS.body.decode('utf8')
if FLAGS['kind'].present:
request.kind = FLAGS.kind.decode('utf8')
if FLAGS['name'].present:
request.name = FLAGS.name.decode('utf8')
result = client.template.Patch(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
class TemplateUpdate(apitools_base_cli.NewCmd):
"""Command wrapping template.Update."""
usage = """template_update <tableId> <templateId>"""
def __init__(self, name, fv):
super(TemplateUpdate, self).__init__(name, fv)
flags.DEFINE_string(
'automaticColumnNames',
None,
u'List of columns from which the template is to be automatically '
u'constructed. Only one of body or automaticColumns can be specified.',
flag_values=fv)
flags.DEFINE_string(
'body',
None,
u'Body of the template. It contains HTML with {column_name} to insert'
u' values from a particular column. The body is sanitized to remove '
u'certain tags, e.g., script. Only one of body or automaticColumns '
u'can be specified.',
flag_values=fv)
flags.DEFINE_string(
'kind',
u'fusiontables#template',
u'Type name: a template for the info window contents. The template '
u'can either include an HTML body or a list of columns from which the'
u' template is computed automatically.',
flag_values=fv)
flags.DEFINE_string(
'name',
None,
u'Optional name assigned to a template.',
flag_values=fv)
def RunWithArgs(self, tableId, templateId):
"""Updates an existing template
Args:
tableId: Identifier for the table for which the template is defined.
templateId: Identifier for the template, unique within the context of a
particular table.
Flags:
automaticColumnNames: List of columns from which the template is to be
automatically constructed. Only one of body or automaticColumns can be
specified.
body: Body of the template. It contains HTML with {column_name} to
insert values from a particular column. The body is sanitized to
remove certain tags, e.g., script. Only one of body or
automaticColumns can be specified.
kind: Type name: a template for the info window contents. The template
can either include an HTML body or a list of columns from which the
template is computed automatically.
name: Optional name assigned to a template.
"""
client = GetClientFromFlags()
global_params = GetGlobalParamsFromFlags()
request = messages.Template(
tableId=tableId.decode('utf8'),
templateId=templateId,
)
if FLAGS['automaticColumnNames'].present:
request.automaticColumnNames = [x.decode('utf8') for x in FLAGS.automaticColumnNames]
if FLAGS['body'].present:
request.body = FLAGS.body.decode('utf8')
if FLAGS['kind'].present:
request.kind = FLAGS.kind.decode('utf8')
if FLAGS['name'].present:
request.name = FLAGS.name.decode('utf8')
result = client.template.Update(
request, global_params=global_params)
print apitools_base_cli.FormatOutput(result)
def main(_):
appcommands.AddCmd('pyshell', PyShell)
appcommands.AddCmd('column_delete', ColumnDelete)
appcommands.AddCmd('column_get', ColumnGet)
appcommands.AddCmd('column_insert', ColumnInsert)
appcommands.AddCmd('column_list', ColumnList)
appcommands.AddCmd('column_patch', ColumnPatch)
appcommands.AddCmd('column_update', ColumnUpdate)
appcommands.AddCmd('query_sql', QuerySql)
appcommands.AddCmd('query_sqlGet', QuerySqlGet)
appcommands.AddCmd('style_delete', StyleDelete)
appcommands.AddCmd('style_get', StyleGet)
appcommands.AddCmd('style_insert', StyleInsert)
appcommands.AddCmd('style_list', StyleList)
appcommands.AddCmd('style_patch', StylePatch)
appcommands.AddCmd('style_update', StyleUpdate)
appcommands.AddCmd('table_copy', TableCopy)
appcommands.AddCmd('table_delete', TableDelete)
appcommands.AddCmd('table_get', TableGet)
appcommands.AddCmd('table_importRows', TableImportRows)
appcommands.AddCmd('table_importTable', TableImportTable)
appcommands.AddCmd('table_insert', TableInsert)
appcommands.AddCmd('table_list', TableList)
appcommands.AddCmd('table_patch', TablePatch)
appcommands.AddCmd('table_update', TableUpdate)
appcommands.AddCmd('task_delete', TaskDelete)
appcommands.AddCmd('task_get', TaskGet)
appcommands.AddCmd('task_list', TaskList)
appcommands.AddCmd('template_delete', TemplateDelete)
appcommands.AddCmd('template_get', TemplateGet)
appcommands.AddCmd('template_insert', TemplateInsert)
appcommands.AddCmd('template_list', TemplateList)
appcommands.AddCmd('template_patch', TemplatePatch)
appcommands.AddCmd('template_update', TemplateUpdate)
apitools_base_cli.SetupLogger()
if hasattr(appcommands, 'SetDefaultCommand'):
appcommands.SetDefaultCommand('pyshell')
run_main = apitools_base_cli.run_main
if __name__ == '__main__':
appcommands.Run()