def _build_subcommand_table(self): subcommand_table = OrderedDict() for subcommand in self.SUBCOMMANDS: subcommand_name = subcommand['name'] subcommand_class = subcommand['command_class'] subcommand_table[subcommand_name] = subcommand_class() self._add_lineage(subcommand_table) return subcommand_table
def create_help_command(self): command_table = OrderedDict() for command_name, command in self._get_command_table().items(): command_table[command_name] = command return ServiceHelpCommand(obj=self._get_service_model(), command_table=command_table, arg_table=None, command_lineage='.'.join(self.lineage_names), name=self._name)
def build_model(self): shapes = OrderedDict() denormalized = { 'type': OBJECT_TYPE, 'properties': self._members, } self._build_model(denormalized, shapes, self.name) resolver = ShapeResolver(shapes) return ObjectShape(name=self.name, shape_data=shapes[self.name], shape_resolver=resolver)
def create_argument_table(self, arguments): if not arguments: return OrderedDict() argument_table = OrderedDict() for arg in arguments: if isinstance(arg, BaseCLIArgument): argument_table[arg.name] = arg else: argument_table[arg] = BaseCLIArgument(arg) return argument_table
def create_command_table(self, clidriver, commands, command_creator): if not commands: return OrderedDict() command_table = OrderedDict() for name, command in commands.items(): if isinstance(command, CLICommand): # Already a valid command, no need to fake one command_table[name] = command else: command_table[name] = command_creator(clidriver, name, command) return command_table
def _get_signature_header(self, signature): auth_params = OrderedDict() auth_params['access_key_id'] = self.credentials.access_key_id auth_params['auth_method'] = self.auth_method encoded_auth_params = json.dumps(auth_params).encode('utf-8') return "%s.%s" % (urlsafe_b64encode( encoded_auth_params).strip().decode('utf-8'), signature)
def _build_command_table(self): commands = OrderedDict() services = self._get_available_services() for service_name in services: commands[service_name] = ServiceCommand(self, service_name) ConfigureCommand.add_command(commands) return commands
def _generate_type_map(self, shape): key_shape = shape.key value_shape = shape.value assert key_shape.type_name == 'string' return OrderedDict([ ('KeyName', self.generate_skeleton(value_shape)), ])
def serialize_to_request(self, parameters, operation_model): # Don't serialize any parameter with a None value. filtered_parameters = OrderedDict( (k, v) for k, v in parameters.items() if v is not None) serialized = {} serialized['method'] = operation_model.http['method'] serialized['headers'] = {'Content-Type': 'application/json'} serialized['url_path'] = operation_model.http['requestUri'] serialized_body = OrderedDict() if len(filtered_parameters) != 0: self._serialize(serialized_body, filtered_parameters, operation_model.input_shape) serialized['body'] = json.dumps(serialized_body).encode( self.DEFAULT_ENCODING) return serialized
def _build_argument_table(self): argument_table = OrderedDict() cli_data = self._get_cli_data() cli_arguments = cli_data.get('options', None) for option in cli_arguments: option_params = copy_kwargs(cli_arguments[option]) cli_argument = self._create_cli_argument(option, option_params) cli_argument.add_to_arg_table(argument_table) return argument_table
def _build_object(self, model, shapes): members = OrderedDict() shape = self._build_initial_shape(model) shape['properties'] = members for name, member_model in model['properties'].items(): member_shape_name = self._get_shape_name(member_model) members[name] = {REF_KEY: REF_NAME_PREFIX + member_shape_name} self._build_model(member_model, shapes, member_shape_name) return shape
def _serialize_type_object(self, serialized, value, shape, key): if key is not None: # If a key is provided, this is a result of a recursive call, so we # need to add a new child dict as the value of the passed in dict. # Below we will add all the structure members to the new serialized # dictionary we just created. serialized[key] = OrderedDict() serialized = serialized[key] for member_key, member_value in value.items(): member_shape = shape.members[member_key] self._serialize(serialized, member_value, member_shape, member_key)
def _create_help_command(self): cli_data = self._get_cli_data() # We filter service aliases out of the service list at the bottom of the # top level help. commands = OrderedDict() for service_name, command in self._get_command_table().items(): if not self._loader.is_service_alias(service_name): commands[service_name] = command return ProviderHelpCommand(commands, self._get_argument_table(), cli_data.get('description', None), cli_data.get('synopsis', None), cli_data.get('help_usage', None))
def _build_arg_table(self): arg_table = OrderedDict() argument_model = None for arg_data in self.ARG_TABLE: # If a custom schema was passed in, create the argument_model # so that it can be validated and docs can be generated. if 'schema' in arg_data: argument_model = create_argument_model_from_schema( arg_data.pop('schema')) arg_data['argument_model'] = argument_model custom_argument = CustomArgument(**arg_data) arg_table[arg_data['name']] = custom_argument if argument_model: add_cli_input_json(argument_model, arg_table) add_generate_skeleton(argument_model, arg_table) self.argument_model = argument_model return arg_table
def _create_argument_table(self): argument_table = OrderedDict() input_shape = self._operation_model.input_shape required_arguments = [] arg_dict = {} if input_shape is not None: required_arguments = input_shape.required_members arg_dict = input_shape.members for arg_name, arg_shape in arg_dict.items(): cli_arg_name = xform_name(arg_name, '-') arg_class = self.ARG_TYPES.get(arg_shape.type_name, self.DEFAULT_ARG_CLASS) is_required = arg_name in required_arguments arg_object = arg_class(name=cli_arg_name, argument_model=arg_shape, is_required=is_required, operation_model=self._operation_model, serialized_name=arg_name, no_paramfile=arg_shape.is_no_paramfile) arg_object.add_to_arg_table(argument_table) add_pagination_params(self._operation_model, argument_table) add_cli_input_json(self._operation_model, argument_table) add_generate_skeleton(self._operation_model, argument_table) return argument_table
def _create_command_table(self): command_table = OrderedDict() service_model = self._get_service_model() for operation_name in service_model.operation_names: cli_name = xform_name(operation_name, '-') operation_model = service_model.operation_model(operation_name) command_table[cli_name] = ServiceOperation( name=cli_name, parent_name=self._name, operation_model=operation_model, operation_caller=CLIOperationCaller()) try: __import__('cdpcli.extensions.%s.register' % self._name, fromlist=['register']).register(command_table) except ImportError as err: py3_err = "No module named 'cdpcli.extensions.%s'" % self._name py2_err = "No module named %s.register" % self._name if py2_err not in str(err) and py3_err not in str(err): # Looks like a different error than missing extensions. LOG.warn("Failed to import service (%s) extension: %s", self._name, err) pass self._add_lineage(command_table) return command_table
def construct_mapping(loader, node): loader.flatten_mapping(node) return OrderedDict(loader.construct_pairs(node))
def __init__(self, name=None): self.members = OrderedDict() self._name_generator = ShapeNameGenerator() if name is None: self.name = self._name_generator.new_shape_name('object')
def members(self): members = OrderedDict() for name, shape_data in self._shape_data.get('properties', {}).items(): members[name] = self._get_shape(name, shape_data) return members
def _generate_type_object(self, shape): skeleton = OrderedDict() for member_name, member_shape in shape.members.items(): skeleton[member_name] = self.generate_skeleton(member_shape) return skeleton