Create a new redis client and assign it the class _redis_client
        attribute for reuse across requests.

        :rtype: tornadoredis.Client()
165313
def _new_redis_client(self):
        
        if 'tornadoredis' not in globals():
            import tornadoredis
        kwargs = self._redis_connection_settings()
        LOGGER.info('Connecting to %(host)s:%(port)s DB %(selected_db)s',
                    kwargs)
        return tornadoredis.Client(**kwargs)
465829
def client(self):
        
        if self._client is None:
            self._client = Client_(self.servers)
        return self._client
960587
def client(self, *args, **kwargs):
        

        return self._makeApiCall(self.funcinfo["client"], *args, **kwargs)
202771
def client(*args, loop=None, **kwargs):
    
    return _get_default_session(loop=loop).client(*args, **kwargs)
361770
def create_redis_client(redis_address, password=None):
    
    redis_ip_address, redis_port = redis_address.split(":")
    # For this command to work, some other client (on the same machine
    # as Redis) must have run "CONFIG SET protected-mode no".
    return redis.StrictRedis(
        host=redis_ip_address, port=int(redis_port), password=password)
1371517
public static RedissonReactiveClient createReactive() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return createReactive(config);
    }
522007
public Client<? extends Options, ? extends OptionsBuilder, ? extends RequestBuilder> newClient() {
        if (clientClassName == null) {
            return new DefaultClient();
        } else {
            try {
                return (Client) Thread.currentThread().getContextClassLoader().loadClass(clientClassName).newInstance();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
1098079
public void useNewRESTServiceWithOldClient() throws Exception {
        List<Object> providers = createJAXRSProviders();

        com.example.customerservice.CustomerService customerService = JAXRSClientFactory
            .createFromModel("http://localhost:" + port + "/examples/direct/new-rest", 
                             com.example.customerservice.CustomerService.class,
                             "classpath:/model/CustomerService-jaxrs.xml", 
                             providers, 
                             null);
        
        // The outgoing old Customer data needs to be transformed for 
        // the new service to understand it and the response from the new service
        // needs to be transformed for this old client to understand it.
        ClientConfiguration config = WebClient.getConfig(customerService);
        addTransformInterceptors(config.getInInterceptors(),
                                 config.getOutInterceptors(),
                                 false);
        
        
        System.out.println("Using new RESTful CustomerService with old Client");

        customer.v1.Customer customer = createOldCustomer("Smith Old to New REST");
        customerService.updateCustomer(customer);

        customer = customerService.getCustomerByName("Smith Old to New REST");
        printOldCustomerDetails(customer);
    }
498990
def from_url(url, db=None, **kwargs):
    
    from redis.client import Redis
    return Redis.from_url(url, db, **kwargs)
876682
function redis (redis) {
    // redis is being set
    if (defined(redis)) {
        // promisify redis if not already promisified
        if (!defined(redis.mgetAsync)) {
            throw new Error('redis must be promisified')
        }
        // create new cache instance
        this.cache = new ImmutableCoreModelCache({
            model: this,
            redis: redis,
        })
        // return model on set
        return this
    }
    // get existing redis client if any
    else if (defined(this.cache)) {
        return this.cache.redis
    }
}
1205041
def instantiate_client(self, config):
        
        modules = config.module.split('.')
        class_name = modules.pop()
        module_path = '.'.join(modules)

        client_instance = getattr(
            __import__(module_path, {}, {}, ['']),
            class_name
        )()

        client_instance.add_config(config)

        return client_instance
81422
def oauth_client_create(self, name, redirect_uri, **kwargs):
        
        params = {
            "label": name,
            "redirect_uri": redirect_uri,
        }
        params.update(kwargs)

        result = self.client.post('/account/oauth-clients', data=params)

        if not 'id' in result:
            raise UnexpectedResponseError('Unexpected response when creating OAuth Client!',
                    json=result)

        c = OAuthClient(self.client, result['id'], result)
        return c
1236053
public static RedissonRxClient createRx() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return createRx(config);
    }
367365
function createClient(redisClientOptions) {
  const client = redis.createClient(redisClientOptions);
  if (!client._options) {
    client._options = redisClientOptions;
  }
  return client;
}
802172
def run_with_tornado(self):
        
        from zengine.tornado_server.server import runserver
        runserver(self.manager.args.addr, int(self.manager.args.port))
182157
def instantiate_client(_unused_client, _unused_to_delete):
    """"""

    # [START client_create_default]
    from google.cloud import logging

    client = logging.Client()
    # [END client_create_default]

    credentials = object()
    # [START client_create_explicit]
    from google.cloud import logging

    client = logging.Client(project="my-project", credentials=credentials)
728294
def client(self):
        
        if self._client is not None:
            return self._client

        self._client = self.get_client()
        return self._client