Update the configuration for this lane if a custom analysis is specified.
359018
def _update_config_w_custom(config, lane_info):
    
    config = copy.deepcopy(config)
    custom = config["custom_algorithms"].get(lane_info.get("analysis", None),
            None)
    if custom:
        for key, val in custom.iteritems():
            config["algorithm"][key] = val
    return config
446034
def _update_settings(self, dialect):
        """"""

        # the first parameter is the dialect itself --> ignore
        for parameter in self.csv_params[2:]:
            pname, ptype, plabel, phelp = parameter

            widget = self._widget_from_p(pname, ptype)

            if ptype is types.TupleType:
                ptype = types.ObjectType

            digest = Digest(acceptable_types=[ptype])

            if pname == 'self.has_header':
                if self.has_header is not None:
                    widget.SetValue(digest(self.has_header))
            else:
                value = getattr(dialect, pname)
                widget.SetValue(digest(value))
1284762
private void configureAnalysisFeatures() {
        for (AnalysisFeatureSetting setting : analysisOptions.analysisFeatureSettingList) {
            setting.configure(AnalysisContext.currentAnalysisContext());
        }
        AnalysisContext.currentAnalysisContext().setBoolProperty(AnalysisFeatures.MERGE_SIMILAR_WARNINGS,
                analysisOptions.mergeSimilarWarnings);
    }
967512
def update(self, **kwargs):
        """"""
        self._check_exclusive_parameters(**kwargs)
        return super(Rule, self)._update(**kwargs)
178356
def with_updated_configuration(self, options=None,
                                   attribute_options=None):
        
        return self._mapping.with_updated_configuration(options=options,
                                                        attribute_options=
                                                            attribute_options)
526697
def extra_prepare(self, configuration, args_dict):
        """"""
        dashmat = args_dict.pop("dashmat")

        self.configuration.update(
          { "dashmat": dashmat
          }
        , source = "<args_dict>"
        )
966856
@Override
    public void updateConfigurations(String commit, Collection<String> paths) {
        Map<String, Configuration> configurationsMap = getConfigurationMap(commit, paths);
        paths.forEach(path -> notifyUpdated(configurationsMap
            .getOrDefault(path, new Configuration(path, null))));
    }
1132338
public void updateLaneView(@NonNull BannerComponents lane, @NonNull String maneuverModifier) {
    if (hasInvalidData(lane)) {
      return;
    }

    TurnLaneViewData drawData = buildTurnLaneViewData(lane, maneuverModifier);
    Integer resId = findDrawableResId(drawData);
    if (resId == null) {
      return;
    }
    drawFor(lane, drawData, resId);
  }
1222449
def _configure(changes):

    '''
    
    '''

    cfgred = True
    reasons = []
    fun = 'update_config'

    for key in ['added', 'updated', 'removed']:
        _updated_changes = changes.get(key, {})
        if not _updated_changes:
            continue
        _location = _updated_changes.get('location', '')
        _contact = _updated_changes.get('contact', '')
        _community = _updated_changes.get('community', {})
        _chassis_id = _updated_changes.get('chassis_id', '')
        if key == 'removed':
            fun = 'remove_config'
        _ret = __salt__['snmp.{fun}'.format(fun=fun)](location=_location,
                                                      contact=_contact,
                                                      community=_community,
                                                      chassis_id=_chassis_id,
                                                      commit=False)
        cfgred = cfgred and _ret.get('result')
        if not _ret.get('result') and _ret.get('comment'):
            reasons.append(_ret.get('comment'))

    return {
        'result': cfgred,
        'comment': '\n'.join(reasons) if reasons else ''
    }
974067
def set_lane_set_list(self, value):
        
        if value is None or not isinstance(value, list):
            raise TypeError("LaneSetList new value must be a list")
        else:
            for element in value:
                if not isinstance(element, lane_set.LaneSet):
                    raise TypeError("LaneSetList elements in variable must be of LaneSet class")
            self.__lane_set_list = value
1159373
def update(cls, settings):
        """"""
        for key, val in settings.__dict__.items():
            if key.startswith('_'):
                continue
            setattr(cls, key, val)
134318
static public void update(Configuration configs)
    {
        scoringPolicy = configs.get(MalmoMod.SCORING_CONFIGS, "policy", DEFAULT_NO_SCORING).getInt();
        if (scoringPolicy > 0) {
            String customLogHandler = configs.get(MalmoMod.SCORING_CONFIGS, "handler", "").getString();
            setLogging(Level.INFO, customLogHandler);
        }
        if (logging)
            log("<ScoreInit><Policy>" + scoringPolicy + "</Policy></ScoreInit>");
    }
17425
def update_info(self, custom=None):
        
        self.figure.suptitle(self.info_string() if custom is None else custom)
514852
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqi1*con.tind)
1061656
def update_features(self, poly):
        """"""

        for feature in self.features:
            feature.wavelength = poly(feature.xpos)
239450
def update(self, response, **kwargs):
        '''
        
        '''
        response_cls = super(
            LocationResponseClassLegacyAccessor, self)._get_instance(**kwargs)
        if response_cls:
            setattr(response_cls, self.column, self.accessor(response))
            setattr(
                response_cls, self.venue_column, self.venue_accessor(response))
            _action_and_commit(response_cls, session.add)
543615
def setLaneChangeMode(self, vehID, lcm):
        
        self._connection._sendIntCmd(
            tc.CMD_SET_VEHICLE_VARIABLE, tc.VAR_LANECHANGE_MODE, vehID, lcm)