Get the fixed params of the network.

        :return: List of strings, names of the layers
170524
def get_fixed_param_names(self) -> List[str]:
        
        args = set(self.args.keys()) | set(self.auxs.keys())

        return list(args & set(self.sym.list_arguments()))
1142558
def getParam(self, name=None):
        
        if 'parameters' in self.keys():
            l = {x['name']: x['value'] for x in self['parameters'].values()}
            if name:
                if name in l.keys():
                    return l[name]
                else:
                    return False
            else:
                return l
826990
def get_connection_params(self):
        
        return {
            'uri': self.settings_dict['NAME'],
            'tls': self.settings_dict.get('TLS', False),
            'bind_dn': self.settings_dict['USER'],
            'bind_pw': self.settings_dict['PASSWORD'],
            'retry_max': self.settings_dict.get('RETRY_MAX', 1),
            'retry_delay': self.settings_dict.get('RETRY_DELAY', 60.0),
            'options': {
                k if isinstance(k, int) else k.lower(): v
                for k, v in self.settings_dict.get('CONNECTION_OPTIONS', {}).items()
            },
        }
1283875
def get_available_parameters(self):
        

        # At the moment, we rely on regex to extract the list of available
        # parameters. A tighter integration with waf would allow for a more
        # natural extraction of the information.

        stdout = self.run_program("%s %s" % (self.script_executable,
                                             '--PrintHelp'),
                                  environment=self.environment,
                                  native_spec=BUILD_GRID_PARAMS)

        options = re.findall('.*Program\s(?:Arguments|Options):(.*)'
                             'General\sArguments.*',
                             stdout, re.DOTALL)

        if len(options):
            args = re.findall('.*--(.*?):.*', options[0], re.MULTILINE)
            return args
        else:
            return []
373654
def params_values(self):
        
        return [p.value for p in atleast_list(self.params) if p.has_value]
264717
def get_parameters(self, packet_count=None):
        
        params = super(InMemCapture, self).get_parameters(packet_count=packet_count)
        params += ['-i', '-']
        return params
157287
def get_connection_params(self):
        """"""
        from django.conf import settings
        settings_dict = self.settings_dict
        options = settings_dict.get('OPTIONS', {})
        autocommit = options.get('autocommit', False)
        conn_params = {
            'server': settings_dict['HOST'],
            'database': settings_dict['NAME'],
            'user': settings_dict['USER'],
            'port': settings_dict.get('PORT', '1433'),
            'password': settings_dict['PASSWORD'],
            'timeout': self.command_timeout,
            'autocommit': autocommit,
            'use_mars': options.get('use_mars', False),
            'load_balancer': options.get('load_balancer', None),
            'failover_partner': options.get('failover_partner', None),
            'use_tz': utc if getattr(settings, 'USE_TZ', False) else None,
         }

        for opt in _SUPPORTED_OPTIONS:
            if opt in options:
                conn_params[opt] = options[opt]

        self.tzinfo_factory = utc_tzinfo_factory if settings.USE_TZ else None

        return conn_params
939532
def free_param_names(self):
        
        p = CombinedBounds(self.k.free_param_names, self.noise_k.free_param_names)
        if self.mu is not None:
            p = CombinedBounds(p, self.mu.free_param_names)
        return p
393119
def get_params(self):
        
        assert self.binded and self.params_initialized

        if self._params_dirty:
            self._sync_params_from_devices()
        return (self._arg_params, self._aux_params)
1180784
def get_param_text(self, nid):
        
        r = []
        params = self.parameters.xpath('.//param[@ref-id="{}"]'.format(nid))
        if not params:
            return r
        for param in params:
            vnode = param.find('value')
            s = 'Parameter: {}, type:{}, value: {}'.format(param.attrib.get('name'),
                                                           vnode.attrib.get('type'),
                                                           param.findtext('value', default='No Value'))
            r.append(s)
        return r
1194379
def get_cfn_parameters(self):
        
        variables = self.get_variables()
        output = {}
        for key, value in variables.items():
            if hasattr(value, "to_parameter_value"):
                output[key] = value.to_parameter_value()
        return output
419658
def parameters(self):
        
        nodes = []
        self._process(Nature.LPAREN)

        while self.token.nature != Nature.RPAREN:

            nodes.append(Parameters(variable=self.logical_or_expr()))

            if self.token.nature == Nature.COMMA:
                self._process(Nature.COMMA)

        self._process(Nature.RPAREN)
        return nodes
478228
def get_params(self):
        
        params = {}
        complex = False

        for name, opt in self.filter_options.items():
            if opt.ignored:
                continue
            if self.set_param(params, name):
                complex = True
        return params, complex
876837
def parameters(self):
        

        return self.block_tl, self.block_br, self.rows, self.cols, self.cells
382797
def get_limits(self):
        
        if self.limits != {}:
            return self.limits
        limits = {}
        limits.update(self._get_limits_instances())
        limits.update(self._get_limits_networking())
        limits.update(self._get_limits_spot())
        self.limits = limits
        return self.limits
379038
def fixed_values(self):
        
        values = []
        values.extend([ prefix_factor(param) * param['value'] for param in self.fixed_parameters ])
        values.extend([ prefix_factor(const) * get_constant(const['value']) for const in self.constants ])

        return tuple(values)
7509
def get_parameters(self, packet_count=None):
        
        params = super(LiveRingCapture, self).get_parameters(packet_count=packet_count)
        params += ['-b', 'filesize:' + str(self.ring_file_size), '-b', 'files:' + str(self.num_ring_files), '-w', self.ring_file_name, '-P']
        return params