def get_nimbus_client(env_config=None, host=None, port=None, timeout=7000):
    """Get a Thrift RPC client for Nimbus given project's config file.

    :param env_config: The project's parsed config.
    :type env_config: `dict`
    :param host: The host to use for Nimbus.  If specified, `env_config` will
                 not be consulted.
    :type host: `str`
    :param port: The port to use for Nimbus.  If specified, `env_config` will
                 not be consulted.
    :type port: `int`
    :param timeout: The time to wait (in milliseconds) for a response from
                    Nimbus.
    :param timeout: `int`

    :returns: a ThriftPy RPC client to use to communicate with Nimbus
    """
    if host is None:
        host, port = get_nimbus_host_port(env_config)
    nimbus_client = make_client(
        Nimbus,
        host=host,
        port=port,
        proto_factory=TBinaryProtocolFactory(),
        trans_factory=TFramedTransportFactory(),
        timeout=timeout,
    )
    return nimbus_client

    def client(self):
        client = make_client(
            publication_stats_thrift.PublicationStats,
            self._address,
            self._port
        )

        return client

def re_init():
  try:
    global client
    client = make_client(broker_thrift.TradeService, config.BROKER_HOST, config.BROKER_PORT,
                           proto_factory=TBinaryProtocolFactory(),
                           trans_factory=TFramedTransportFactory(),
                           timeout=60000)  
  except Exception as e:
    logging.warn("make_client exception")
    traceback.print_exc()

def main():
    host            = '127.0.0.1' if len(sys.argv) < 2 else sys.argv[1]
    port            = 9090 if len(sys.argv) < 3 else int(sys.argv[2])
    uniqueid_thrift = thriftpy.load('../protocol/uniqueid.thrift', module_name='uniqueid_thrift')
    client          = make_client(uniqueid_thrift.Uniqueid, host, port)
    request         = uniqueid_thrift.UniqueidRequest()
    request.logid   = random.randint(-2147483648, 2147483647)
    request.serial  = random.randint(0, 9)
    request.length  = random.randint(1, 10)
    response        = client.uniqueid(request)
    print(response)

 def write_multiple(self, spans):
     entries = [self.__span_to_entry(span) for span in spans]
     # TODO(will): The old implementation used to open and close transport here, with the new
     # client based API this seems like the only way to get parity. Not sure if we would rather
     # try persistent connections + reconnecting in the long run.
     client = make_client(scribe_thrift.scribe,
                          host=self.host,
                          port=self.port,
                          timeout=self.timeout,
                          proto_factory=self.protocol_factory,
                          trans_factory=self.transport_factory)
     client.Log(entries)
     client.close()

  def __init__(self):
    # We need to run a FrontendService server, even though it does nothing in
    # practice
    fes = make_server(sparrow_service_thrift.FrontendService,
                      FLAGS.sparrow_frontend_host, FLAGS.sparrow_frontend_port,
                      trans_factory=tf)
    self.scheduler_client = make_client(sparrow_service_thrift.SchedulerService,
                                        FLAGS.sparrow_scheduler_host,
                                        FLAGS.sparrow_scheduler_port,
                                        trans_factory=tf)

    self.scheduler_client.registerFrontend("clusterMixApp",
                                           FLAGS.sparrow_frontend_host + ":" +
                                           str(FLAGS.sparrow_frontend_port))

def handleClient(num, actual):
    # Open independent client connection
    client = make_client(service=echo_thrift.Echo, host='127.0.0.1',
                         port=9999, trans_factory=TFramedTransportFactory())

    # UUID
    uid = str(uuid4())

    for i in range(num):
        # Make thrift call and increment atomic count
        txt = uid + str(i)
        ret = client.echo(echo_thrift.Message(text=txt))
        if (txt == ret):
            with actual.get_lock():
                actual.value += 1

def start_client():
    while True:
        while True:
            try:
                client = make_client(thrift_service.Ping, 'localhost', 9000)
                break
            except:
                continue

        while True:
            try:
                pong = client.ping()
            except:
                break
            print(pong)
            time.sleep(1)
        continue

def getClient():
    wwfAPIpathname = os.path.join('thrift', 'wwf_api.thrift')
    wwfAPI_thrift = thriftpy.load(path=wwfAPIpathname, module_name='wwfAPI_thrift', include_dirs=['thrift'])
    tTransport = TFramedTransportFactory()
    client = make_client(wwfAPI_thrift.WwfApi, port=9090, trans_factory=tTransport)
    return client

#!/usr/bin/env python
# coding: utf-8

import os
import thriftpy

from thriftpy.rpc import make_client


# Examples using thrift
if __name__ == '__main__':

    citedby_thrift = thriftpy.load(os.path.join(os.path.dirname(
                                   os.path.abspath(__file__)), 'citedby.thrift'))

    client = make_client(citedby_thrift.Citedby, 'localhost', 11610)

    print client.citedby_pid('S1516-89132010000300001', False)

    print client.citedby_doi('10.1590/S1516-89132010000300001')

    print client.citedby_meta(title='Biochemical and morphological changes during the growth kinetics of Araucaria angustifolia suspension cultures')

def rpc_call(call, server, *args):
    client = make_client(lang_thrift.CodeExecutor, *server)
    return getattr(client, call)(*args)

 def mk_client(self):
     return make_client(addressbook.AddressBookService,
                        '127.0.0.1', self.port,
                        proto_factory=self.PROTOCOL_FACTORY,
                        trans_factory=self.TRANSPORT_FACTORY)

import thriftpy
pingpong_thrift = thriftpy.load("pingpong.thrift", module_name="pingpong_thrift")

from thriftpy.rpc import make_client

client = make_client(pingpong_thrift.PingPong, '127.0.0.1', 6000)
client.ping()

def send_to_taskqueue(task, task_id, ip, port):
    client = make_client(enqueue_thrift.RPC, ip, port)
    client.task_service(task, task_id)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import thriftpy
from thriftpy.rpc import make_client

pingpong_thrift = thriftpy.load("pingpong.thrift", module_name="pingpong_thrift")

client = make_client(pingpong_thrift.PingPong, '0.0.0.0', 6000)
print client.ping()

 def mk_client(self):
     return make_client(
         addressbook.AddressBookService, "127.0.0.1", self.port, trans_factory=TFramedTransportFactory()
     )

# coding: utf-8
import os
import thriftpy
import json

from thriftpy.rpc import make_client

ratchet_thrift = thriftpy.load(
    os.path.dirname(__file__)+'/ratchet.thrift',
    module_name='ratchet_thrift'
)

if __name__ == "__main__":
    client = make_client(
        ratchet_thrift.RatchetStats,
        '127.0.0.1',
        11630
    )
    print json.loads(client.general('scl'))

import os
import thriftpy
import json

from thriftpy.rpc import make_client

publication_stats_thrift = thriftpy.load(
    os.path.dirname(__file__)+'/publication_stats.thrift',
    module_name='publication_stats_thrift'
)

if __name__ == '__main__':

    client = make_client(
        publication_stats_thrift.PublicationStats,
        'publication.scielo.org',
        11620
    )

    body = {
        "query": {
            "match": {
                "collection": "scl"
            }
        },
        "aggs": {
            "languages": {
                "terms": {
                    "field": "languages"
                }
            }

# coding: utf-8
import os

import thriftpy

articlemeta_thrift = thriftpy.load(
    os.path.dirname(__file__)+'/articlemeta.thrift',
    module_name='articlemeta_thrift'
)

from thriftpy.rpc import make_client

if __name__ == '__main__':
    client = make_client(
        articlemeta_thrift.ArticleMeta,
        'articlemeta.scielo.org',
        11720
    )

    #article = client.get_article('S0034-71672014000600891', collection='scl', replace_journal_metadata=True)

    identifiers = client.get_journal_identifiers(collection='scl', limit=10, offset=0)

    for i in identifiers:
        print i.collection, i.code

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import thriftpy
from thriftpy.rpc import make_client
import os

if __name__ == "__main__":
    file_path = os.path.abspath("../conf/simple.thrift")

    # 加载注册文件
    simple_thrift = thriftpy.load(file_path, module_name="simple_thrift")

    client = make_client(simple_thrift.RPCTest, '192.168.1.105', 6000)
    print client.print_fun("wxmimperio")