Return the list of source for which energy dispersion should be turned off
5080
def edisp_disable_list(self):
        
        l = []
        for model_comp in self.model_components.values():
            if model_comp.edisp_disable:
                l += [model_comp.info.source_name]
        return l
686352
def ignored_regions(source):
    
    return [(match.start(), match.end()) for match in _str.finditer(source)]
1114950
def sources(self):
        

        sources = collections.OrderedDict()

        for d in (self.point_sources, self.extended_sources, self.particle_sources):

            sources.update(d)

        return sources
580385
def stop(self):
        
        super(AggregateDependency, self).stop()

        if self.services:
            return [
                (service, reference)
                for reference, service in self.services.items()
            ]

        return None
656380
def getSynchronizationSources(self):
        
        cutoff = clock.current_datetime() - datetime.timedelta(seconds=10)
        sources = []
        for source, timestamp in self.__active_ssrc.items():
            if timestamp >= cutoff:
                sources.append(RTCRtpSynchronizationSource(source=source, timestamp=timestamp))
        return sources
1125265
def list(host=None, quiet=False, hyper=None):  # pylint: disable=redefined-builtin
    '''
    
    '''
    if quiet:
        log.warning("'quiet' is deprecated. Please migrate to --quiet")
    ret = {}
    client = salt.client.get_local_client(__opts__['conf_file'])
    for info in client.cmd_iter('virtual:physical',
                                'virt.vm_info', tgt_type='grain'):
        if not info:
            continue
        if not isinstance(info, dict):
            continue
        chunk = {}
        id_ = next(six.iterkeys(info))
        if host:
            if host != id_:
                continue
        if not isinstance(info[id_], dict):
            continue
        if 'ret' not in info[id_]:
            continue
        if not isinstance(info[id_]['ret'], dict):
            continue
        data = {}
        for key, val in six.iteritems(info[id_]['ret']):
            if val['state'] in data:
                data[val['state']].append(key)
            else:
                data[val['state']] = [key]
        chunk[id_] = data
        ret.update(chunk)
        if not quiet:
            __jid_event__.fire_event({'data': chunk, 'outputter': 'nested'}, 'progress')

    return ret
1290619
def get_providing_power_source_type(self):
        
        power_status = SYSTEM_POWER_STATUS()
        if not GetSystemPowerStatus(pointer(power_status)):
            raise WinError()
        return POWER_TYPE_MAP[power_status.ACLineStatus]
839867
def random_filtered_sources(sources, srcfilter, seed):
    
    random.seed(seed)
    while sources:
        src = random.choice(sources)
        if srcfilter.get_close_sites(src) is not None:
            return [src]
        sources.remove(src)
    return []
950882
def filtered_list(cls, name=None, obj=None):
        """"""
        options = {}
        if name:
            options['id'] = cls.usable_id(name)

        def obj_ok(dc, obj):
            if not obj or obj['datacenter_id'] == dc['id']:
                return True
            return False

        return [x for x in cls.list(options) if obj_ok(x, obj)]
148256
def list_device_data_sources(self, device_rid):
        
        headers = {
                'User-Agent': self.user_agent(),
        }
        headers.update(self.headers())

        r = requests.get(   self.portals_url()+'/devices/'+device_rid+'/data-sources', 
                    headers=headers, auth=self.auth())
        if HTTP_STATUS.OK == r.status_code:
            return r.json()
        else:
            print("Something went wrong: <{0}>: {1}".format(
                        r.status_code, r.reason))
            return None
445579
def Q(self):
        
        return np.array(list(self.center_frequencies)) \
               / np.array(list(self.bandwidths))
1167836
def power_off
      target = entity_xml
      class_name = self.class.name.split("::").last
      Config.logger.debug "#{class_name} status: #{target[:status]}"
      if is_status?(target, :SUSPENDED)
        error_msg = "#{class_name} #{target.name} suspended, discard state before powering off."
        fail class_name == "VApp" ? VappSuspendedError : VmSuspendedError,
             error_msg
      end
      if is_status?(target, :POWERED_OFF)
        Config.logger.info "#{class_name} #{target.name} is already powered off."
        return
      end

      power_off_link = target.power_off_link
      unless power_off_link
        fail CloudError, "#{class_name} #{target.name} is not in a state that could be powered off."
      end

      task = connection.post(power_off_link.href, nil)
      monitor_task task, @session.time_limit[:power_off]
      Config.logger.info "#{class_name} #{target.name} is powered off."

      undeploy(target, class_name)
      self
    end
866988
def disable(self):
        
        self.engine.data.update(dns_relay_interface=[])
        self.engine.data.pop('dns_relay_profile_ref', None)
854800
public void disableAll(){
		javaMemoryProducers =
		javaMemoryPoolProducers =
		javaThreadingProducers =
		osProducer =
		runtimeProducer =
		mbeanProducers =
		gcProducer =
		errorProducer =
			false;

	}
1220025
private Set<Source> calculateRemovedSources() {
        Set<Source> removed = new HashSet<>();
        for (String src : prev.sources().keySet()) {
            if (now.sources().get(src) == null) {
                removed.add(prev.sources().get(src));
            }
        }
        return removed;
    }
1330703
def disable(self, idx):
        """"""
        if idx not in self.uid.keys():
            self.log('Element index {0} does not exist.'.format(idx))
            return
        self.u[self.uid[idx]] = 0
353412
def list_only():
    """"""
    (cred, providers) = config_read()
    conn_objs = cld.get_conns(cred, providers)
    nodes = cld.get_data(conn_objs, providers)
    node_dict = make_node_dict(nodes, "name")
    table.indx_table(node_dict)