Return the configured providers
340399
def get_configured_providers(self):
        '''
        
        '''
        providers = set()
        for alias, drivers in six.iteritems(self.opts['providers']):
            if len(drivers) > 1:
                for driver in drivers:
                    providers.add('{0}:{1}'.format(alias, driver))
                continue
            providers.add(alias)
        return providers
943708
def get_available_routers(self, dc=None):
        
        mask = "mask[locations]"
        # Step 1, get the package id
        package = self.ordering_manager.get_package_by_key(self.capacity_package, mask="id")

        # Step 2, get the regions this package is orderable in
        regions = self.client.call('Product_Package', 'getRegions', id=package['id'], mask=mask, iter=True)
        _filter = None
        routers = {}
        if dc is not None:
            _filter = {'datacenterName': {'operation': dc}}

        # Step 3, for each location in each region, get the pod details, which contains the router id
        pods = self.client.call('Network_Pod', 'getAllObjects', filter=_filter, iter=True)
        for region in regions:
            routers[region['keyname']] = []
            for location in region['locations']:
                location['location']['pods'] = list()
                for pod in pods:
                    if pod['datacenterName'] == location['location']['name']:
                        location['location']['pods'].append(pod)

        # Step 4, return the data.
        return regions
436114
def get_provider(self, provider_name='default'):
        """"""
        try:
            if self._providers is None:
                self._providers = self._initialize_providers()
            return self._providers[provider_name]
        except KeyError:
            raise AssertionError(f'No Provider registered with name {provider_name}')
237074
def _get_configured_repos(root=None):
    '''
    
    '''

    repos = os.path.join(root, os.path.relpath(REPOS, os.path.sep)) if root else REPOS
    repos_cfg = configparser.ConfigParser()
    if os.path.exists(repos):
        repos_cfg.read([repos + '/' + fname for fname in os.listdir(repos) if fname.endswith(".repo")])
    else:
        log.warning('Repositories not found in %s', repos)

    return repos_cfg
170684
def get_provider(self, name):
        """"""
        if name not in self.providers:
            cls = self.provider_classes[name]
            # instantiate the provider
            self.providers[name] = cls(self)
        return self.providers[name]
32508
def configuration(self):
        
        if self._configuration is None:
            self._configuration = ConfigurationList(self)
        return self._configuration
260056
public static function getAllProviders()
    {
        if (is_null(self::$providers)) {
            self::$providers = array();
            $plugins   = PluginManager::getInstance()->getPluginsLoadedAndActivated();
            foreach ($plugins as $plugin) {
                foreach (self::getLocationProviders($plugin) as $instance) {
                    self::$providers[] = $instance;
                }
            }
        }

        return self::$providers;
    }
620001
def available_providers(request):
    ""
    if APPENGINE:
        # Note: AppEngine inequality queries are limited to one property.
        # See https://developers.google.com/appengine/docs/python/datastore/queries#Python_Restrictions_on_queries
        # Users have also noted that the exclusion queries don't work
        # See https://github.com/mlavin/django-all-access/pull/46
        # So this is lazily-filtered in Python
        qs = SimpleLazyObject(lambda: _get_enabled())
    else:
        qs = Provider.objects.filter(consumer_secret__isnull=False, consumer_key__isnull=False)
    return {'allaccess_providers': qs}
542673
def get_config(self):
        ''
        return (self.bus.read_byte_data(self.address, self.CONTROL_PORT0), self.bus.read_byte_data(self.address, self.CONTROL_PORT1));
1040114
def get_configuration(self):
        
        mapping = {}
        settings = self.get_settings()
        for service in self.context.getService():
            uid = api.get_uid(service)
            setting = settings.get(uid, {})
            config = {
                "hidden": setting.get("hidden", False),
            }
            mapping[uid] = config
        return mapping
1360432
def get_configuration(self):
        
        mapping = {}
        settings = self.get_settings()
        for record in self.context.getAnalyses():
            uid = record.get("service_uid")
            setting = settings.get(uid, {})
            config = {
                "partition": record.get("partition"),
                "hidden": setting.get("hidden", False),
            }
            mapping[uid] = config
        return mapping
1217402
def get_driver(secret_key=config.DEFAULT_SECRET_KEY, userid=config.DEFAULT_USERID,
               provider=config.DEFAULT_PROVIDER):

    """"""

    if hasattr(config, 'get_driver'):
        logger.debug('get_driver %s' % config.get_driver)
        return config.get_driver()
    else:
        logger.debug('get_driver {0}@{1}'.format(userid, provider))
        return libcloud.compute.providers.get_driver(
            config.PROVIDERS[provider])(userid, secret_key)
990482
public function getDefaultProviders()
    {
        $endpoint = "{$this->apiUrl}/providers/true";

        $res = Requests::get($endpoint);
        $this->validateResponse($res);

        return json_decode($res->body, true);
    }
916524
def get_connection(self, provider_name='default'):
        """"""
        try:
            return self._providers[provider_name].get_connection()
        except KeyError:
            raise AssertionError(f'No Provider registered with name {provider_name}')
1198432
public function registerConfiguredProviders()
	{
		$manifestPath = $this->basePath() . '/vendor/services.json';

		(new ProviderRepository($this, new Filesystem, $manifestPath))
		            ->load($this->config['app.providers']);
	}
337878
private function getProvidersConfig()
    {
        $config = [];
        foreach (self::PROVIDERS as $provider) {
            $config[ucfirst($provider)] = [
                'enabled' => (bool)$this->scopeConfig->getValue(
                    sprintf(self::CONFIG_PATH_SOCIAL_LOGIN_PROVIDER_ENABLED, $provider),
                    ScopeInterface::SCOPE_STORE
                ),
                'keys' => [
                    'key' => $this->scopeConfig->getValue(
                        sprintf(self::CONFIG_PATH_SOCIAL_LOGIN_PROVIDER_KEY, $provider),
                        ScopeInterface::SCOPE_STORE
                    ),
                    'secret' => $this->scopeConfig->getValue(
                        sprintf(self::CONFIG_PATH_SOCIAL_LOGIN_PROVIDER_SECRET, $provider),
                        ScopeInterface::SCOPE_STORE
                    ),
                ]
            ];
        }
        return $config;
    }
936808
def configurationStore(self):
        """"""
        url = self._url + "/configstore"

        return ConfigurationStore(url=url,
                                  securityHandler=self._securityHandler,
                                  proxy_url=self._proxy_url,
                                  proxy_port=self._proxy_port)