350 lines
11 KiB
Python
350 lines
11 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# Copyright 2015 Google Inc.
|
|
#
|
|
# 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.
|
|
|
|
"""Command-line interface to gen_client."""
|
|
|
|
import argparse
|
|
import contextlib
|
|
import io
|
|
import json
|
|
import logging
|
|
import os
|
|
import pkgutil
|
|
import sys
|
|
|
|
from apitools.base.py import exceptions
|
|
from apitools.gen import gen_client_lib
|
|
from apitools.gen import util
|
|
|
|
|
|
def _CopyLocalFile(filename):
|
|
with contextlib.closing(io.open(filename, 'w')) as out:
|
|
src_data = pkgutil.get_data(
|
|
'apitools.base.py', filename)
|
|
if src_data is None:
|
|
raise exceptions.GeneratedClientError(
|
|
'Could not find file %s' % filename)
|
|
out.write(src_data)
|
|
|
|
|
|
def _GetDiscoveryDocFromFlags(args):
|
|
"""Get the discovery doc from flags."""
|
|
if args.discovery_url:
|
|
try:
|
|
return util.FetchDiscoveryDoc(args.discovery_url)
|
|
except exceptions.CommunicationError:
|
|
raise exceptions.GeneratedClientError(
|
|
'Could not fetch discovery doc')
|
|
|
|
infile = os.path.expanduser(args.infile) or '/dev/stdin'
|
|
with io.open(infile, encoding='utf8') as f:
|
|
return json.loads(util.ReplaceHomoglyphs(f.read()))
|
|
|
|
|
|
def _GetCodegenFromFlags(args):
|
|
"""Create a codegen object from flags."""
|
|
discovery_doc = _GetDiscoveryDocFromFlags(args)
|
|
names = util.Names(
|
|
args.strip_prefix,
|
|
args.experimental_name_convention,
|
|
args.experimental_capitalize_enums)
|
|
|
|
if args.client_json:
|
|
try:
|
|
with io.open(args.client_json, encoding='utf8') as client_json:
|
|
f = json.loads(util.ReplaceHomoglyphs(client_json.read()))
|
|
web = f.get('installed', f.get('web', {}))
|
|
client_id = web.get('client_id')
|
|
client_secret = web.get('client_secret')
|
|
except IOError:
|
|
raise exceptions.NotFoundError(
|
|
'Failed to open client json file: %s' % args.client_json)
|
|
else:
|
|
client_id = args.client_id
|
|
client_secret = args.client_secret
|
|
|
|
if not client_id:
|
|
logging.warning('No client ID supplied')
|
|
client_id = ''
|
|
|
|
if not client_secret:
|
|
logging.warning('No client secret supplied')
|
|
client_secret = ''
|
|
|
|
client_info = util.ClientInfo.Create(
|
|
discovery_doc, args.scope, client_id, client_secret,
|
|
args.user_agent, names, args.api_key, args.version_identifier)
|
|
outdir = os.path.expanduser(args.outdir) or client_info.default_directory
|
|
if os.path.exists(outdir) and not args.overwrite:
|
|
raise exceptions.ConfigurationValueError(
|
|
'Output directory exists, pass --overwrite to replace '
|
|
'the existing files.')
|
|
if not os.path.exists(outdir):
|
|
os.makedirs(outdir)
|
|
|
|
return gen_client_lib.DescriptorGenerator(
|
|
discovery_doc, client_info, names, args.root_package, outdir,
|
|
base_package=args.base_package,
|
|
protorpc_package=args.protorpc_package,
|
|
init_wildcards_file=(args.init_file == 'wildcards'),
|
|
use_proto2=args.experimental_proto2_output,
|
|
unelidable_request_methods=args.unelidable_request_methods,
|
|
apitools_version=args.apitools_version)
|
|
|
|
|
|
# TODO(user): Delete this if we don't need this functionality.
|
|
def _WriteBaseFiles(codegen):
|
|
with util.Chdir(codegen.outdir):
|
|
_CopyLocalFile('base_api.py')
|
|
_CopyLocalFile('credentials_lib.py')
|
|
_CopyLocalFile('exceptions.py')
|
|
|
|
|
|
def _WriteIntermediateInit(codegen):
|
|
with io.open('__init__.py', 'w') as out:
|
|
codegen.WriteIntermediateInit(out)
|
|
|
|
|
|
def _WriteProtoFiles(codegen):
|
|
with util.Chdir(codegen.outdir):
|
|
with io.open(codegen.client_info.messages_proto_file_name, 'w') as out:
|
|
codegen.WriteMessagesProtoFile(out)
|
|
with io.open(codegen.client_info.services_proto_file_name, 'w') as out:
|
|
codegen.WriteServicesProtoFile(out)
|
|
|
|
|
|
def _WriteGeneratedFiles(args, codegen):
|
|
if codegen.use_proto2:
|
|
_WriteProtoFiles(codegen)
|
|
with util.Chdir(codegen.outdir):
|
|
with io.open(codegen.client_info.messages_file_name, 'w') as out:
|
|
codegen.WriteMessagesFile(out)
|
|
with io.open(codegen.client_info.client_file_name, 'w') as out:
|
|
codegen.WriteClientLibrary(out)
|
|
|
|
|
|
def _WriteInit(codegen):
|
|
with util.Chdir(codegen.outdir):
|
|
with io.open('__init__.py', 'w') as out:
|
|
codegen.WriteInit(out)
|
|
|
|
|
|
def _WriteSetupPy(codegen):
|
|
with io.open('setup.py', 'w') as out:
|
|
codegen.WriteSetupPy(out)
|
|
|
|
|
|
def GenerateClient(args):
|
|
|
|
"""Driver for client code generation."""
|
|
|
|
codegen = _GetCodegenFromFlags(args)
|
|
if codegen is None:
|
|
logging.error('Failed to create codegen, exiting.')
|
|
return 128
|
|
_WriteGeneratedFiles(args, codegen)
|
|
if args.init_file != 'none':
|
|
_WriteInit(codegen)
|
|
|
|
|
|
def GeneratePipPackage(args):
|
|
|
|
"""Generate a client as a pip-installable tarball."""
|
|
|
|
discovery_doc = _GetDiscoveryDocFromFlags(args)
|
|
package = discovery_doc['name']
|
|
original_outdir = os.path.expanduser(args.outdir)
|
|
args.outdir = os.path.join(
|
|
args.outdir, 'apitools/clients/%s' % package)
|
|
args.root_package = 'apitools.clients.%s' % package
|
|
codegen = _GetCodegenFromFlags(args)
|
|
if codegen is None:
|
|
logging.error('Failed to create codegen, exiting.')
|
|
return 1
|
|
_WriteGeneratedFiles(args, codegen)
|
|
_WriteInit(codegen)
|
|
with util.Chdir(original_outdir):
|
|
_WriteSetupPy(codegen)
|
|
with util.Chdir('apitools'):
|
|
_WriteIntermediateInit(codegen)
|
|
with util.Chdir('clients'):
|
|
_WriteIntermediateInit(codegen)
|
|
|
|
|
|
def GenerateProto(args):
|
|
"""Generate just the two proto files for a given API."""
|
|
|
|
codegen = _GetCodegenFromFlags(args)
|
|
_WriteProtoFiles(codegen)
|
|
|
|
|
|
class _SplitCommaSeparatedList(argparse.Action):
|
|
|
|
def __call__(self, parser, namespace, values, option_string=None):
|
|
setattr(namespace, self.dest, values.split(','))
|
|
|
|
|
|
def main(argv=None):
|
|
if argv is None:
|
|
argv = sys.argv
|
|
parser = argparse.ArgumentParser(
|
|
description='Apitools Client Code Generator')
|
|
|
|
discovery_group = parser.add_mutually_exclusive_group()
|
|
discovery_group.add_argument(
|
|
'--infile',
|
|
help=('Filename for the discovery document. Mutually exclusive with '
|
|
'--discovery_url'))
|
|
|
|
discovery_group.add_argument(
|
|
'--discovery_url',
|
|
help=('URL (or "name.version") of the discovery document to use. '
|
|
'Mutually exclusive with --infile.'))
|
|
|
|
parser.add_argument(
|
|
'--base_package',
|
|
default='apitools.base.py',
|
|
help='Base package path of apitools (defaults to apitools.base.py')
|
|
|
|
parser.add_argument(
|
|
'--protorpc_package',
|
|
default='apitools.base.protorpclite',
|
|
help=('Base package path of protorpc '
|
|
'(defaults to apitools.base.protorpclite'))
|
|
|
|
parser.add_argument(
|
|
'--version-identifier',
|
|
help=('Version identifier to use for the generated client (defaults to '
|
|
'"version" value in discovery doc). This must be a valid '
|
|
'identifier when used in a Python module name.'))
|
|
|
|
parser.add_argument(
|
|
'--outdir',
|
|
default='',
|
|
help='Directory name for output files. (Defaults to the API name.)')
|
|
|
|
parser.add_argument(
|
|
'--overwrite',
|
|
default=False, action='store_true',
|
|
help='Only overwrite the output directory if this flag is specified.')
|
|
|
|
parser.add_argument(
|
|
'--root_package',
|
|
default='',
|
|
help=('Python import path for where these modules '
|
|
'should be imported from.'))
|
|
|
|
parser.add_argument(
|
|
'--strip_prefix', nargs='*',
|
|
default=[],
|
|
help=('Prefix to strip from type names in the discovery document. '
|
|
'(May be specified multiple times.)'))
|
|
|
|
parser.add_argument(
|
|
'--api_key',
|
|
help=('API key to use for API access.'))
|
|
|
|
parser.add_argument(
|
|
'--client_json',
|
|
help=('Use the given file downloaded from the dev. console for '
|
|
'client_id and client_secret.'))
|
|
|
|
parser.add_argument(
|
|
'--client_id',
|
|
default='CLIENT_ID',
|
|
help='Client ID to use for the generated client.')
|
|
|
|
parser.add_argument(
|
|
'--client_secret',
|
|
default='CLIENT_SECRET',
|
|
help='Client secret for the generated client.')
|
|
|
|
parser.add_argument(
|
|
'--scope', nargs='*',
|
|
default=[],
|
|
help=('Scopes to request in the generated client. '
|
|
'May be specified more than once.'))
|
|
|
|
parser.add_argument(
|
|
'--user_agent',
|
|
default='x_Tw5K8nnjoRAqULM9PFAC2b',
|
|
help=('User agent for the generated client. '
|
|
'Defaults to <api>-generated/0.1.'))
|
|
|
|
parser.add_argument(
|
|
'--generate_cli', dest='generate_cli', action='store_true',
|
|
help='Ignored.')
|
|
parser.add_argument(
|
|
'--nogenerate_cli', dest='generate_cli', action='store_false',
|
|
help='Ignored.')
|
|
|
|
parser.add_argument(
|
|
'--init-file',
|
|
choices=['none', 'empty', 'wildcards'],
|
|
type=lambda s: s.lower(),
|
|
default='wildcards',
|
|
help='Controls whether and how to generate package __init__.py file.')
|
|
|
|
parser.add_argument(
|
|
'--unelidable_request_methods',
|
|
action=_SplitCommaSeparatedList,
|
|
default=[],
|
|
help=('Full method IDs of methods for which we should NOT try to '
|
|
'elide the request type. (Should be a comma-separated list.'))
|
|
|
|
parser.add_argument(
|
|
'--apitools_version',
|
|
default='', dest='apitools_version',
|
|
help=('Apitools version used as a requirement in generated clients. '
|
|
'Defaults to version of apitools used to generate the clients.'))
|
|
|
|
parser.add_argument(
|
|
'--experimental_capitalize_enums',
|
|
default=False, action='store_true',
|
|
help='Dangerous: attempt to rewrite enum values to be uppercase.')
|
|
|
|
parser.add_argument(
|
|
'--experimental_name_convention',
|
|
choices=util.Names.NAME_CONVENTIONS,
|
|
default=util.Names.DEFAULT_NAME_CONVENTION,
|
|
help='Dangerous: use a particular style for generated names.')
|
|
|
|
parser.add_argument(
|
|
'--experimental_proto2_output',
|
|
default=False, action='store_true',
|
|
help='Dangerous: also output a proto2 message file.')
|
|
|
|
subparsers = parser.add_subparsers(help='Type of generated code')
|
|
|
|
client_parser = subparsers.add_parser(
|
|
'client', help='Generate apitools client in destination folder')
|
|
client_parser.set_defaults(func=GenerateClient)
|
|
|
|
pip_package_parser = subparsers.add_parser(
|
|
'pip_package', help='Generate apitools client pip package')
|
|
pip_package_parser.set_defaults(func=GeneratePipPackage)
|
|
|
|
proto_parser = subparsers.add_parser(
|
|
'proto', help='Generate apitools client protos')
|
|
proto_parser.set_defaults(func=GenerateProto)
|
|
|
|
args = parser.parse_args(argv[1:])
|
|
return args.func(args) or 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(main())
|