def __init__()

in ebcli/objects/requests.py [0:0]

• 78 lines of code
• 16 McCabe index (conditional complexity)

    def __init__(self, app_name=None, env_name=None, cname=None, platform=None,
                 tier=None, instance_type=None, version_label=None,
                 instance_profile=None, service_role=None,
                 single_instance=False, key_name=None,
                 sample_application=False, tags=None, scale=None,
                 database=None, vpc=None, template_name=None, group_name=None,
                 elb_type=None, shared_lb=None, shared_lb_port=None, enable_spot=None, instance_types=None,
                 spot_max_price=None, on_demand_base_capacity=None,
                 on_demand_above_base_capacity=None, min_instances=None,
                 max_instances=None, block_device_mappings=None, listener_configs=None,
                 description=None, load_balancer_security_group=None, ec2_security_group=None,
                 ssl_certificate=None, root_volume=None):
        self.app_name = app_name
        self.cname = cname
        self.env_name = env_name
        self.instance_profile = instance_profile
        self.instance_type = instance_type
        self.key_name = key_name
        self.platform = platform
        self.sample_application = sample_application
        self.service_role = service_role
        self.single_instance = single_instance
        self.template_name = template_name
        self.tier = tier
        self.version_label = version_label
        self.group_name = group_name
        if tags is None:
            self.tags = []
        else:
            self.tags = list(tags)
        if database is None:
            self.database = {}
        else:
            self.database = dict(database)
        if vpc is None:
            self.vpc = {}
        else:
            self.vpc = dict(vpc)

        self.elb_type = elb_type
        self.shared_lb = shared_lb
        self.shared_lb_port = shared_lb_port
        self.scale = None
        self.option_settings = []
        self.compiled = False
        self.description = description or strings['env.description']
        self.enable_spot = enable_spot
        self.instance_types = instance_types
        self.spot_max_price = spot_max_price
        self.on_demand_base_capacity = on_demand_base_capacity
        self.on_demand_above_base_capacity = on_demand_above_base_capacity
        self.min_instances = min_instances
        self.max_instances = max_instances
        self.block_device_mappings = block_device_mappings
        self.ssl_certificate = ssl_certificate
        if listener_configs:
            self.merge_option_settings(listener_configs)
        if load_balancer_security_group:
            self.merge_option_settings([load_balancer_security_group])
        if ec2_security_group:
            security_groups_expressed_through_vpc_config = self.vpc and self.vpc.get('securitygroups')
            if not security_groups_expressed_through_vpc_config :
                self.merge_option_settings([ec2_security_group])

        if not self.app_name:
            raise TypeError(self.__class__.__name__ + ' requires key-word argument app_name')
        if not self.env_name:
            raise TypeError(self.__class__.__name__ + ' requires key-word argument env_name')

        if scale:
            if not isinstance(scale, int):
                raise TypeError('key-word argument scale must be of type int')
            else:
                self.scale = str(scale)
        if ssl_certificate:
            self.add_option_setting(
                namespaces.LOAD_BALANCER_V2,
                option_names.SSL_CERT_ID,
                ssl_certificate)
        if root_volume:
            self.merge_option_settings(root_volume)