Gets the LogicalSwitches API client.

        Returns:
            LogicalSwitches:
5967
def logical_switches(self):
        
        if not self.__logical_switches:
            self.__logical_switches = LogicalSwitches(self.__connection)
        return self.__logical_switches
723108
def _default_client(jws_client, reactor, key, alg):
    
    if jws_client is None:
        pool = HTTPConnectionPool(reactor)
        agent = Agent(reactor, pool=pool)
        jws_client = JWSClient(HTTPClient(agent=agent), key, alg)
    return jws_client
1232477
private DirectoryServiceClient decideClient(){
        DirectoryServiceClient client;
        switch (config.getClientType()) {
            case RESTFUL:
                client = restfulClient;
                break;
            case DUMMY:
                client = dummyClient;
                break;
            case IN_MEMORY:
                client = new DirectoryServiceInMemoryClient();
                break;
            case PROVIDED:
                DirectoryServiceClientProvider provider = clientProvider.get();
                if (provider != null) {
                    client = provider.getClient();
                } else {
                    throw new IllegalStateException("No DirectoryServiceClientProvider is set up for Client Type PROVIDED");
                }
                break;
            default:
                //don't support other client type now.
                throw new IllegalStateException("UNKNOWN Client Type " + config.getClientType());
        }
        return client;
    }
262132
def fetch_interfaces(self):
        
        return get('ISteamWebAPIUtil', 'GetSupportedAPIList', 1,
            https=self.https,
            apihost=self.apihost,
            caller=None,
            session=self.session,
            params={'format': 'json',
                    'key': self.key,
                    },
            )
204145
def enabled_logical_ids(self):
        
        return [logical_id for logical_id, preference in self._resource_preferences.items() if preference.enabled]
327920
def get_client_info(self):
        
        iq = aioxmpp.IQ(
            to=self.client.local_jid.bare().replace(localpart=None),
            type_=aioxmpp.IQType.GET,
            payload=xso.Query()
        )

        reply = (yield from self.client.send(iq))
        return reply
465829
def client(self):
        
        if self._client is None:
            self._client = Client_(self.servers)
        return self._client
343928
def get_CrossCatClient(client_type, **kwargs):
    """"""
    client = None

    if client_type == 'local':
        import crosscat.LocalEngine as LocalEngine
        le = LocalEngine.LocalEngine(**kwargs)
        client = CrossCatClient(le)

    elif client_type == 'multiprocessing':
        import crosscat.MultiprocessingEngine as MultiprocessingEngine
        me =  MultiprocessingEngine.MultiprocessingEngine(**kwargs)
        client = CrossCatClient(me)

    else:
        raise Exception('unknown client_type: %s' % client_type)

    return client
112170
def _get_selected_cipher_suite(
            server_connectivity: ServerConnectivityInfo,
            ssl_version: OpenSslVersionEnum,
            openssl_cipher_str: str,
            should_use_legacy_openssl: Optional[bool]
    ) -> 'AcceptedCipherSuite':
        
        ssl_connection = server_connectivity.get_preconfigured_ssl_connection(
            override_ssl_version=ssl_version, should_use_legacy_openssl=should_use_legacy_openssl
        )
        ssl_connection.ssl_client.set_cipher_list(openssl_cipher_str)

        # Perform the SSL handshake
        try:
            ssl_connection.connect()
            selected_cipher = AcceptedCipherSuite.from_ongoing_ssl_connection(ssl_connection, ssl_version)
        except ClientCertificateRequested:
            selected_cipher = AcceptedCipherSuite.from_ongoing_ssl_connection(ssl_connection, ssl_version)
        finally:
            ssl_connection.close()
        return selected_cipher
1000471
def do_get_logical_switch_config(self, line):
        

        def f(p, args):
            try:
                source, lsw = args
            except:
                print("argument error")
                return
            o = p.get_config(source)
            for l in o.logical_switches.switch:
                if l.id != lsw:
                    continue
                print(l.id)
                for k in self._lsw_settings:
                    try:
                        v = getattr(l, k)
                    except AttributeError:
                        continue
                    print('%s %s' % (k, v))

        self._request(line, f)
31876
def get_client(self, name):
        
        mech = self.get(name)
        return mech if isinstance(mech, ClientMechanism) else None
226622
def GetClientOs(client_id, token=None):
  """"""
  if data_store.RelationalDBEnabled():
    kb = data_store.REL_DB.ReadClientSnapshot(client_id).knowledge_base
  else:
    with aff4.FACTORY.Open(client_id, token=token) as client:
      kb = client.Get(client.Schema.KNOWLEDGE_BASE)

  return kb.os
880575
def client(self):
        
        if self._client is None:
            self._client = KeycloakClient(server_url=self._server_url,
                                          headers=self._headers)
        return self._client
29503
def switch_client(self):
        
        proc = self.cmd('switch-client', '-t%s' % self.id)

        if proc.stderr:
            raise exc.LibTmuxException(proc.stderr)
367182
@NonNull
    private static OkHttpClient getNewOkHttpClient(boolean enableTLS) {
        OkHttpClient.Builder client = new OkHttpClient.Builder()
                .connectTimeout(DEFAULT_CONNECT_TIMEOUT, TimeUnit.SECONDS)
                .readTimeout(DEFAULT_READ_TIMEOUT, TimeUnit.SECONDS);
        if (enableTLS) {
            client = enableTls12(client);
        }
        return client.build();
    }
911202
def get_client(client_id):
    
    client = Client.query.get(client_id)
    if client and client.user.active:
        return client
623958
def get(self, sid):
        
        return WorkerChannelContext(
            self._version,
            workspace_sid=self._solution['workspace_sid'],
            worker_sid=self._solution['worker_sid'],
            sid=sid,
        )