Gets the ApplianceDeviceReadCommunity API client.

        Returns:
            ApplianceDeviceReadCommunity:
512816
def appliance_device_read_community(self):
        
        if not self.__appliance_device_read_community:
            self.__appliance_device_read_community = ApplianceDeviceReadCommunity(self.__connection)
        return self.__appliance_device_read_community
417518
def get(self, sid):
        
        return EnvironmentContext(self._version, service_sid=self._solution['service_sid'], sid=sid, )
18846
def http_client(self):
        ''''''
        client = http.HttpClient(decompress=False, store_cookies=False)
        client.headers.clear()
        return client
354510
def client(self):
        
        if self._client is not None:
            return self._client
        self._client = vospace.client
        return self._client
706048
public ConsumerSession getConsumerSession() 
  throws SISessionUnavailableException, SISessionDroppedException,
         SIIncorrectCallException

  {
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.entry(CoreSPILockedMessageEnumeration.tc, "getConsumerSession", this);
      
    checkValidState("getConsumerSession");
          
    _localConsumerPoint.checkNotClosed();
    
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.exit(CoreSPILockedMessageEnumeration.tc, "getConsumerSession", 
        _localConsumerPoint.getConsumerSession());
    
    return _localConsumerPoint.getConsumerSession();
  }
225563
private synchronized RealmOAuthConsumer getConsumer() {
        // could just inject these, but I kinda prefer pushing this out
        // to the properties file...
        if (consumer == null) {
            OAuthServiceProvider serviceProvider = new OAuthServiceProvider("", "", "");
            String realm =
                    propertyResolver.getProperty(
                            "org.jasig.rest.interceptor.oauth." + id + ".realm");
            String consumerKey =
                    propertyResolver.getProperty(
                            "org.jasig.rest.interceptor.oauth." + id + ".consumerKey");
            String secretKey =
                    propertyResolver.getProperty(
                            "org.jasig.rest.interceptor.oauth." + id + ".secretKey");

            Assert.notNull(
                    consumerKey,
                    "The property \"org.jasig.rest.interceptor.oauth."
                            + id
                            + ".consumerKey\" must be set.");
            Assert.notNull(
                    secretKey,
                    "The property \"org.jasig.rest.interceptor.oauth."
                            + id
                            + ".secretKey\" must be set.");

            consumer = new RealmOAuthConsumer(consumerKey, secretKey, realm, serviceProvider);
        }

        return consumer;
    }
331346
def _get_client(self):
        
        client_kwargs = self._storage_parameters.get('client', dict())

        # Handles unsecure mode
        if self._unsecure:
            client_kwargs = client_kwargs.copy()
            client_kwargs['use_ssl'] = False

        return self._get_session().client("s3", **client_kwargs)
35980
def get_client(provider, token=''):
    ""
    cls = OAuth2Client
    if provider.request_token_url:
        cls = OAuthClient
    return cls(provider, token)
82112
def get_client(client_type, **kwargs):
    '''
    
    '''
    client_map = {'compute': 'ComputeManagement',
                  'authorization': 'AuthorizationManagement',
                  'dns': 'DnsManagement',
                  'storage': 'StorageManagement',
                  'managementlock': 'ManagementLock',
                  'monitor': 'MonitorManagement',
                  'network': 'NetworkManagement',
                  'policy': 'Policy',
                  'resource': 'ResourceManagement',
                  'subscription': 'Subscription',
                  'web': 'WebSiteManagement'}

    if client_type not in client_map:
        raise SaltSystemExit(
            msg='The Azure ARM client_type {0} specified can not be found.'.format(
                client_type)
        )

    map_value = client_map[client_type]

    if client_type in ['policy', 'subscription']:
        module_name = 'resource'
    elif client_type in ['managementlock']:
        module_name = 'resource.locks'
    else:
        module_name = client_type

    try:
        client_module = importlib.import_module('azure.mgmt.'+module_name)
        # pylint: disable=invalid-name
        Client = getattr(client_module,
                         '{0}Client'.format(map_value))
    except ImportError:
        raise sys.exit(
                  'The azure {0} client is not available.'.format(client_type)
        )

    credentials, subscription_id, cloud_env = _determine_auth(**kwargs)

    if client_type == 'subscription':
        client = Client(
            credentials=credentials,
            base_url=cloud_env.endpoints.resource_manager,
        )
    else:
        client = Client(
            credentials=credentials,
            subscription_id=subscription_id,
            base_url=cloud_env.endpoints.resource_manager,
        )

    client.config.add_user_agent('Salt/{0}'.format(salt.version.__version__))

    return client
1232262
def instance_admin_api(self):
        """"""
        if self._instance_admin_api is None:
            self._instance_admin_api = InstanceAdminClient(
                credentials=self.credentials, client_info=_CLIENT_INFO
            )
        return self._instance_admin_api
1118632
def service(self, *args, **kwargs):
        
        return self._client.service(*args, scope=self.id, **kwargs)
832261
def client(self):
        """"""
        if self._client is None:
            self._client = self._client_builder()
        return self._client
1115680
public static snmpcommunity[] get(nitro_service service) throws Exception{
		snmpcommunity obj = new snmpcommunity();
		snmpcommunity[] response = (snmpcommunity[])obj.get_resources(service);
		return response;
	}
428915
def _get_service_endpoint(context, svc, region=None, public=True):
    
    region = _safe_region(region)
    # If a specific context is passed, use that. Otherwise, use the global
    # identity reference.
    context = context or identity
    url_type = {True: "public", False: "private"}[public]
    svc_obj = context.services.get(svc)
    if not svc_obj:
        return None
    ep = svc_obj.endpoints.get(region, {}).get(url_type)
    if not ep:
        # Try the "ALL" region, and substitute the actual region
        ep = svc_obj.endpoints.get("ALL", {}).get(url_type)
    return ep
366963
def _GetServiceKey():
  """"""
  global _service_key

  if _service_key is None:
    hive = getattr(winreg, config.CONFIG["Client.config_hive"])
    path = config.CONFIG["Client.config_key"]

    # Don't use winreg.KEY_WOW64_64KEY since it breaks on Windows 2000
    _service_key = winreg.CreateKeyEx(hive, path, 0, winreg.KEY_ALL_ACCESS)

  return _service_key
801241
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return EntityInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            identity=self._solution['identity'],
        )
820704
def get(cls):
        
        apikey = cls.__api_key or cls.__api_key_env_var

        if apikey:
            return apikey
        else:
            raise APIKeyMissingError("API key not set")