from thrift import Thrift from thrift.transport import THttpClient from thrift.transport import TTransport from thrift.protocol import TBinaryProtocol from thrift.protocol import TJSONProtocol from thrift.server import THttpServer from livetex.dialog.ttypes import * from livetex.operator.ttypes import * from livetex.dialog import ClientDialog try: transport = THttpClient.THttpClient('http://*****:*****@example.example' operator.options = {'opt1': 'val1'}
from gen_py.datahub import DataHub from gen_py.datahub.constants import * from thrift import Thrift from thrift.protocol import TBinaryProtocol from thrift.transport import THttpClient from thrift.transport import TTransport ''' @author: anant bhardwaj @date: Oct 11, 2013 Sample Python client for DataHub ''' try: transport = THttpClient.THttpClient('http://datahub.csail.mit.edu/service') transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = DataHub.Client(protocol) print "Version: %s" %(client.get_version()) # open connection con_params = ConnectionParams(user='******', password='******') con = client.open_connection(con_params=con_params) # execute a query res = client.execute_sql( con=con, query='select * from anantb.test.demo', query_params=None)
def _get_client(self, options): url = urlparse(options.url) host, port = self._parse_host_port(url[1], 80) transport = THttpClient.THttpClient(options.url) return self._get_client_by_transport(options, transport)
def Shop(self, isopen=True): self.transport = THttpClient.THttpClient(self.host) self.transport.setCustomHeaders(self.headers) self.protocol = TCompactProtocol.TCompactProtocol(self.transport) self._shop = ShopService.Client(self.protocol)
def __init__( self, uri=None, user=None, password=None, host=None, port=6274, dbname=None, protocol='binary', sessionid=None, bin_cert_validate=None, bin_ca_certs=None, idpurl=None, idpformusernamefield='username', idpformpasswordfield='password', idpsslverify=True, ): self.sessionid = None if sessionid is not None: if any([user, password, uri, dbname, idpurl]): raise TypeError("Cannot specify sessionid with user, password," " dbname, uri, or idpurl") if uri is not None: if not all([ user is None, password is None, host is None, port == 6274, dbname is None, protocol == 'binary', bin_cert_validate is None, bin_ca_certs is None, idpurl is None, ]): raise TypeError("Cannot specify both URI and other arguments") ( user, password, host, port, dbname, protocol, bin_cert_validate, bin_ca_certs, ) = _parse_uri(uri) if host is None: raise TypeError("`host` parameter is required.") if protocol != 'binary' and not all( [bin_cert_validate is None, bin_ca_certs is None]): raise TypeError("Cannot specify bin_cert_validate or bin_ca_certs," " without binary protocol") if protocol in ("http", "https"): if not host.startswith(protocol): # the THttpClient expects http[s]://localhost host = '{0}://{1}'.format(protocol, host) transport = THttpClient.THttpClient("{}:{}".format(host, port)) proto = TJSONProtocol.TJSONProtocol(transport) socket = None elif protocol == "binary": if any([bin_cert_validate is not None, bin_ca_certs]): socket = TSSLSocket.TSSLSocket( host, port, validate=(bin_cert_validate), ca_certs=bin_ca_certs, ) else: socket = TSocket.TSocket(host, port) transport = TTransport.TBufferedTransport(socket) proto = TBinaryProtocol.TBinaryProtocolAccelerated(transport) else: raise ValueError( "`protocol` should be one of" " ['http', 'https', 'binary']," " got {} instead".format(protocol), ) self._user = user self._password = password self._host = host self._port = port self._dbname = dbname self._transport = transport self._protocol = protocol self._socket = socket self._closed = 0 self._tdf = None self._rbc = None try: self._transport.open() except TTransportException as e: if e.NOT_OPEN: err = OperationalError("Could not connect to database") raise err from e else: raise self._client = Client(proto) try: # If a sessionid was passed, we should validate it if sessionid: self._session = sessionid self.get_tables() self.sessionid = sessionid else: if idpurl: self._user = '' self._password = get_saml_response( username=user, password=password, idpurl=idpurl, userformfield=idpformusernamefield, passwordformfield=idpformpasswordfield, sslverify=idpsslverify, ) self._dbname = '' self._idpsslverify = idpsslverify user = self._user password = self._password dbname = self._dbname self._session = self._client.connect(user, password, dbname) except TOmniSciException as e: raise _translate_exception(e) from e except TTransportException: raise ValueError(f"Connection failed with port {port} and " f"protocol '{protocol}'. Try port 6274 for " "protocol == binary or 6273, 6278 or 443 for " "http[s]") # if OmniSci version <4.6, raise RuntimeError, as data import can be # incorrect for columnar date loads # Caused by https://github.com/omnisci/pymapd/pull/188 semver = self._client.get_version() if Version(semver.split("-")[0]) < Version("4.6"): raise RuntimeError(f"Version {semver} of OmniSci detected. " "Please use pymapd <0.11. See release notes " "for more details.")
def login(self): """Login to LINE server.""" if self.provider == CurveThrift.Provider.LINE: # LINE j = self.get_json(self.LINE_SESSION_LINE_URL) else: # NAVER j = self.get_json(self.LINE_SESSION_NAVER_URL) session_key = j['session_key'] message = (chr(len(session_key)) + session_key + chr(len(self.id)) + self.id + chr(len(self.password)) + self.password).encode('utf-8') keyname, n, e = j['rsa_key'].split(",") pub_key = rsa.PublicKey(int(n,16), int(e,16)) crypto = rsa.encrypt(message, pub_key).encode('hex') self.transport = THttpClient.THttpClient(self.LINE_HTTP_URL) self.transport.setCustomHeaders(self._headers) self.protocol = TCompactProtocol.TCompactProtocol(self.transport) self._client = CurveThrift.Client(self.protocol) try: with open(self.CERT_FILE,'r') as f: self.certificate = f.read() f.close() except: self.certificate = "" msg = self._client.loginWithIdentityCredentialForCertificate( self.id, self.password, keyname, crypto, False, self.ip, self.com_name, self.provider, self.certificate) if msg.type == 1: self.certificate = msg.certificate self.authToken = self._headers['X-Line-Access'] = msg.authToken elif msg.type == 2: msg = "require QR code" self.raise_error(msg) elif msg.type == 3: self._headers['X-Line-Access'] = msg.verifier self._pinCode = msg.pinCode print "Enter PinCode '%s' to your mobile phone in 2 minutes"\ % self._pinCode j = self.get_json(self.LINE_CERTIFICATE_URL) self.verifier = j['result']['verifier'] msg = self._client.loginWithVerifierForCertificate(self.verifier) if msg.type == 1: if msg.certificate is not None: with open(self.CERT_FILE,'w') as f: f.write(msg.certificate) self.certificate = msg.certificate if msg.authToken is not None: self.authToken = self._headers['X-Line-Access'] = msg.authToken return True else: return False else: msg = "Require device confirm" self.raise_error(msg) #raise Exception("Code is removed because of the request of LINE corporation") else: self.authToken = self._headers['X-Line-Access'] = msg.authToken return True
from PointService import PointService from PointService.ttypes import * from thrift.transport import THttpClient from thrift.protocol import TCompactProtocol authToken = "" headers = { "User-Agent": "Line/10.1.1", "X-Line-Application": "IOS\t10.1.1\tiPhone 8\t11.2.5", "x-lal": "en_US", "X-Line-Carrier": "52003", "X-Line-Access": authToken, } transport = THttpClient.THttpClient("https://ga2s.line.naver.jp/POINT4") transport.setCustomHeaders(headers) protocol = TCompactProtocol.TCompactProtocol(transport) client = PointService.Client(protocol) transport.open() print(client.getBalance(GetBalanceRequest()))
from thrift.transport import THttpClient import time import sys sys.path.append('D:/thrift/gen-py') from ttypes import * import UserService import traceback import logging import assertpy sys.path.append('D:/thrift') from config import * from client_api import * transport = THttpClient.THttpClient( '10.32.173.200', 8085, '/XK_Phr_Proxy/UserServlet') # ip port projectname transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = UserService.Client(protocol) msg = MessageInfo() time1 = int(time.time()) msgtime = str(time1) print msg msg = { 'fromPerson': 'M5A1CFEDBE4B09F03008C774D', 'toPerson': 'M55FA54FBE4B0BB9D487A7D17', 'messageTime': msgtime, 'messageType': '1', 'messageContent': '123sgfdg', 'serviceid': '',
# -*- coding: utf-8 -*- # 以下两个模块可以通过 pip install thrift 安装获得 from thrift.protocol import TBinaryProtocol from thrift.transport import THttpClient # 下面的模块通过 thrift --gen py hbase.thrift 来生成 from hbase import THBaseService from hbase.ttypes import TColumnValue, TColumn, TTableName, TTableDescriptor, TColumnFamilyDescriptor, TNamespaceDescriptor, TGet, TPut, TScan # 连接地址 url = "http://ld-bp1n9k5e2skw959z5-proxy-hbaseue-pub.hbaseue.rds.aliyuncs.com:9190" transport = THttpClient.THttpClient(url) headers = {} # 用户名 headers["ACCESSKEYID"] = "root" # 密码 headers["ACCESSSIGNATURE"] = "root" transport.setCustomHeaders(headers) protocol = TBinaryProtocol.TBinaryProtocolAccelerated(transport) client = THBaseService.Client(protocol) transport.open() # create Namespace client.createNamespace(TNamespaceDescriptor(name="ns")) # create table tableName = TTableName(ns="ns", qualifier="table1") client.createTable( TTableDescriptor(tableName=tableName, columns=[TColumnFamilyDescriptor(name="f")]), None) # 做DML操作时,表名参数为bytes,表名的规则是namespace + 冒号 + 表名 tableInbytes = "ns:table1".encode("utf8") # 插入数据 client.put(table=tableInbytes, tput=TPut(row="row1".encode("utf8"),
def __init__(self, host, port, uri): self.transport = THttpClient.THttpClient(host, port, uri) self.protocol = TJSONProtocol.TJSONProtocol(self.transport) self.client = codeCheckerDBAccess.Client(self.protocol)
def main(): try: parser = argparse.ArgumentParser() parser.add_argument('--path', '-p', action='store', help='Path to synchronize directory') parser.add_argument( '--mask', '-m', action='store', help='Mask of files to synchronize. Default is "*.*"') parser.add_argument( '--format', '-f', action='store', default='plain', choices=['plain', 'markdown', 'html'], help= 'The format of the file contents. Default is "plain". Valid values are "plain" "html" and "markdown"' ) parser.add_argument( '--notebook', '-n', action='store', help= 'Notebook name for synchronize. Default is default notebook unless all is selected' ) parser.add_argument('--all', '-a', action='store_true', help='Synchronize all notebooks', default=False) parser.add_argument('--all-linked', action='store_true', help='Get all linked notebooks') parser.add_argument( '--logpath', '-l', action='store', help='Path to log file. Default is GeekNoteSync in home dir') parser.add_argument('--two-way', '-t', action='store_true', help='Two-way sync (also download from evernote)', default=False) parser.add_argument('--download-only', action='store_true', help='Only download from evernote; no upload', default=False) parser.add_argument( '--nodownsync', '-d', action='store', help='Sync from Evernote only if the file is already local.') parser.add_argument('--save-images', action='store_true', help='save images along with text') parser.add_argument('--sleep-on-ratelimit', action='store_true', help='sleep on being ratelimited') parser.add_argument( '--images-in-subdir', action='store_true', help= 'save images in a subdirectory (instead of same directory as file)' ) args = parser.parse_args() path = args.path if args.path else "." mask = args.mask if args.mask else None format = args.format if args.format else None notebook_name = args.notebook if args.notebook else None logpath = args.logpath if args.logpath else None twoway = args.two_way download_only = args.download_only nodownsync = True if args.nodownsync else False # image options imageOptions = {} imageOptions['saveImages'] = args.save_images imageOptions['imagesInSubdir'] = args.images_in_subdir reset_logpath(logpath) geeknote = GeekNote() if args.all_linked: my_map = {} for notebook in all_linked_notebooks(): print "Syncing notebook: " + notebook.shareName notebook_url = urlparse.urlparse(notebook.noteStoreUrl) sharedNoteStoreClient = THttpClient.THttpClient( notebook.noteStoreUrl) sharedNoteStoreProtocol = TBinaryProtocol.TBinaryProtocol( sharedNoteStoreClient) sharedNoteStore = NoteStore.Client(sharedNoteStoreProtocol) sharedAuthResult = sharedNoteStore.authenticateToSharedNotebook( notebook.shareKey, geeknote.authToken) sharedAuthToken = sharedAuthResult.authenticationToken sharedNotebook = sharedNoteStore.getSharedNotebookByAuth( sharedAuthToken) my_filter = NoteStore.NoteFilter( notebookGuid=sharedNotebook.notebookGuid) noteList = sharedNoteStore.findNotes(sharedAuthToken, my_filter, 0, 10) print "Found " + str(noteList.totalNotes) + " shared notes." print noteList.notes filename = notebook.shareName + '-' + noteList.notes[ 0].title + '.html' filename = filename.replace(' ', '-').replace('/', '-') content = sharedNoteStore.getNoteContent( sharedAuthToken, noteList.notes[0].guid) with open(filename, 'w') as f: f.write(content) return if args.all: for notebook in all_notebooks( sleep_on_ratelimit=args.sleep_on_ratelimit): logger.info("Syncing notebook %s (%s)", notebook.name, notebook.guid) escaped_notebook_path = slugify(notebook.name) notebook_path = os.path.join(path, escaped_notebook_path) if not os.path.exists(notebook_path): os.mkdir(notebook_path) GNS = GNSync(notebook.name, notebook_path, mask, format, twoway, download_only, nodownsync, sleep_on_ratelimit=args.sleep_on_ratelimit, imageOptions=imageOptions) GNS.sync() else: GNS = GNSync(notebook_name, path, mask, format, twoway, download_only, nodownsync, sleep_on_ratelimit=args.sleep_on_ratelimit, imageOptions=imageOptions) GNS.sync() except (KeyboardInterrupt, SystemExit, tools.ExitException): pass except Exception, e: logger.exception("gnsync failed")
def getNoteStore(self): noteStoreUri = self.noteStoreUriBase + self.authResult.user.shardId noteStoreHttpClient = THttpClient.THttpClient(noteStoreUri) noteStoreProtocol = TBinaryProtocol.TBinaryProtocol( noteStoreHttpClient) self.noteStore = NoteStore.Client(noteStoreProtocol)
def token(self, to, token, msg_id, sender, nametoken): try: a = token a.update({'x-lpqs': '/api/v4/TalkService.do'}) transport = THttpClient.THttpClient( 'https://gd2.line.naver.jp/api/v4/TalkService.do') transport.setCustomHeaders(a) protocol = TCompactProtocol.TCompactProtocol(transport) clienttoken = LineService.Client(protocol) qr = clienttoken.getAuthQrcode(keepLoggedIn=1, systemName='DENDAM') link = "line://au/q/" + qr.verifier #self.sendReplyMessage(msg_id, to, "Click This Link Only For 2 Minute :)\n\n{}".format(link)) data = { "type": "template", "altText": "Token", "template": { "type": "buttons", "title": "Token %s" % nametoken, "text": "Click This Button\nOnly For 2 Minutes", "actions": [{ "type": "uri", "label": "Click Me", "uri": link }, { "type": "uri", "label": "Link ?", "uri": 'line://app/1603968955-ORWb9RdY/?type=text&text=%s' % link }] } } self.postTemplate(to, data) a.update({ "x-lpqs": '/api/v4/TalkService.do', 'X-Line-Access': qr.verifier }) json.loads(requests.session().get('https://gd2.line.naver.jp/Q', headers=a).text) a.update({'x-lpqs': '/api/v4p/rs'}) transport = THttpClient.THttpClient( 'https://gd2.line.naver.jp/api/v4p/rs') transport.setCustomHeaders(a) protocol = TCompactProtocol.TCompactProtocol(transport) clienttoken = LineService.Client(protocol) req = LoginRequest() req.type = 1 req.verifier = qr.verifier req.e2eeVersion = 1 res = clienttoken.loginZ(req) try: settings = livejson.File('setting.json', True, True, 4) settings['token']['token'] = res.authToken settings['token']['status'] = True self.sendMessage( to, 'Success get your token,\nCek Your Private Chat') except Exception as e: self.sendMessage(to, str(e)) except Exception as error: self.sendMessage(to, "Login Bangsat") self.sendMessage(to, str(error))
def __init__(self): username = settings.EVERNOTE_USER password = settings.EVERNOTE_PW consumerKey = settings.EVERNOTE_CONSUMER_KEY consumerSecret = settings.EVERNOTE_CONSUMER_SECRET evernoteHost = settings.EVERNOTE_HOST userStoreUri = "https://" + evernoteHost + "/edam/user" noteStoreUriBase = "https://" + evernoteHost + "/edam/note/" userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) versionOK = userStore.checkVersion( "Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) if not versionOK: raise Exception("Invalid EDAM Version") # Authenticate the user try: authResult = userStore.authenticate(username, password, consumerKey, consumerSecret) except Errors.EDAMUserException as e: # See http://www.evernote.com/about/developer/api/ref/UserStore.html#Fn_UserStore_authenticate parameter = e.parameter errorCode = e.errorCode errorText = Errors.EDAMErrorCode._VALUES_TO_NAMES[errorCode] print "Authentication failed (parameter: " + parameter + " errorCode: " + errorText + ")" if errorCode == Errors.EDAMErrorCode.INVALID_AUTH: if parameter == "consumerKey": if consumerKey == "en-edamtest": print "You must replace the variables consumerKey and consumerSecret with the values you received from Evernote." else: print "Your consumer key was not accepted by", evernoteHost print "This sample client application requires a client API key. If you requested a web service API key, you must authenticate using OAuth." print "If you do not have an API Key from Evernote, you can request one from http://www.evernote.com/about/developer/api" elif parameter == "username": print "You must authenticate using a username and password from", evernoteHost if evernoteHost != "www.evernote.com": print "Note that your production Evernote account will not work on", evernoteHost print "You must register for a separate test account at https://" + evernoteHost + "/Registration.action" elif parameter == "password": print "The password that you entered is incorrect" print "" exit(1) userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) self.userStore = UserStore.Client(userStoreProtocol) versionOK = self.userStore.checkVersion( "Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) if not versionOK: print "Old EDAM version" exit(1) authResult = self.userStore.authenticate(username, password, consumerKey, consumerSecret) self.authToken = authResult.authenticationToken noteStoreUri = noteStoreUriBase + authResult.user.shardId noteStoreHttpClient = THttpClient.THttpClient(noteStoreUri) noteStoreProtocol = TBinaryProtocol.TBinaryProtocol( noteStoreHttpClient) self.noteStore = NoteStore.Client(noteStoreProtocol)
# sys.path.insert(0, glob.glob('thrift-0.9.2/lib/py/build/lib.*')[0]) sys.path.insert( 0, glob.glob('/mnt/nfs/gpi2/downloads/thrift-0.9.3/lib/py/build/lib.*')[0]) from myfirst import MyFirstService from thrift import Thrift from thrift.transport import THttpClient from thrift.transport import TTransport from thrift.protocol import TBinaryProtocol from random import randint try: socket = THttpClient.THttpClient('localhost', 8765, '/MyFirstServer.php') transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = MyFirstService.Client(protocol) transport.open() # calling log method client.log("logfile.log") print 'logged current time to logfile (not waiting for response)' # calling multiply method with random parameters number1 = randint(1, 100) number2 = randint(1, 100) product = client.multiply(number1, number2) print '%dx%d=%d' % (number1, number2, product)
def __setUserStore(self): # {{{ """ setup userStore. """ userStoreHttpClient = THttpClient.THttpClient(USERSTORE_URI) userStoreProtocol = TBinaryProtocol.TBinaryProtocol(userStoreHttpClient) self.userStore = UserStore.Client(userStoreProtocol)
http = True argi += 2 if sys.argv[argi] == '-f' or sys.argv[argi] == '-framed': framed = True argi += 1 if sys.argv[argi] == '-s' or sys.argv[argi] == '-ssl': ssl = True argi += 1 cmd = sys.argv[argi] args = sys.argv[argi + 1:] if http: transport = THttpClient.THttpClient(host, port, uri) else: socket = TSSLSocket.TSSLSocket( host, port, validate=False) if ssl else TSocket.TSocket(host, port) if framed: transport = TTransport.TFramedTransport(socket) else: transport = TTransport.TBufferedTransport(socket) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = SpacyThrift.Client(protocol) transport.open() if cmd == 'tag': if len(args) != 1: print('tag requires 1 args') sys.exit(1)
def bot(op): try: if op.type == 0: return if op.type == 5: if wait["autoAdd"] == True: cl.findAndAddContactsByMid(op.param1) if (wait["message"] in ["", " ", "\n", None]): pass else: cl.sendText(op.param1, str(wait["message"])) if op.type == 13: if mid in op.param3: if wait["autoJoin"] == True: if op.param2 in creator + admin: cl.acceptGroupInvitation(op.param1) else: cl.rejectGroupInvitation(op.param1) else: print("autoJoin is Off") if op.type == 22: if wait["leaveRoom"] == True: cl.leaveRoom(op.param1) if op.type == 24: if wait["leaveRoom"] == True: cl.leaveRoom(op.param1) if op.type == 26: msg = op.message if msg.toType == 1: if wait["leaveRoom"] == True: cl.leaveRoom(msg.to) if op.type == 26: msg = op.message if msg.text in [".help"]: if msg.from_ in creator + admin: if wait["lang"] == "JP": cl.sendText(msg.to, helpMessage1) if op.type == 26: msg = op.message if msg.text in [".headers"]: if msg.from_ in creator + admin: if wait["lang"] == "JP": cl.sendText(msg.to, helpMessage2) #____________________REBOOT_________________________________ elif msg.text.lower().startswith(".reboot"): if msg.from_ in creator + admin: print("[Command]Reboot") try: cl.sendText(msg.to, "I'Il come back later") cl.sendText(msg.to, "Restarted done ") restart_program() except: cl.sendText(msg.to, "Please wait") restart_program() pass #______________________________ elif msg.text.lower().startswith(".admin:on "): if msg.from_ in creator: if msg.toType == 2: key = eval(msg.contentMetadata["MENTION"]) key["MENTIONEES"][0]["M"] targets = [] for x in key["MENTIONEES"]: targets.append(x["M"]) for target in targets: try: admin.append(target) f = codecs.open('st2__admin.json', 'w', 'utf-8') json.dump([admin], f, sort_keys=True, indent=4, ensure_ascii=False) jp = cl.getContact(target).displayName jp1 = cl.getContact(msg.from_).displayName cl.sendText( msg.to, jp + " has been promoted admin by " + jp1) except: pass #______________________________ elif msg.text.lower().startswith(".expel:on "): if msg.from_ in creator: if msg.toType == 2: key = eval(msg.contentMetadata["MENTION"]) key["MENTIONEES"][0]["M"] targets = [] for x in key["MENTIONEES"]: targets.append(x["M"]) for target in targets: try: admin.remove(target) f = codecs.open('st2__admin.json', 'w', 'utf-8') json.dump([admin], f, sort_keys=True, indent=4, ensure_ascii=False) jp = cl.getContact(target).displayName jp1 = cl.getContact(msg.from_).displayName cl.sendText( msg.to, jp + " has been expelled admin by " + jp1) except: pass #_______________STAFF_________ elif msg.text.lower().startswith(".staff"): if msg.from_ in creator + admin: if creator == []: if admin == []: cl.sendText(msg.to, "Not stafflist") num = 0 mc1 = "" for mi_d in admin: mc1 += "%i - %s\n" % (num, cl.getContact(mi_d).displayName) num = (num + 1) mc2 = "" for mi_d in creator: mc2 += "%i - %s\n" % (num, cl.getContact(mi_d).displayName) num = (num + 1) cl.sendText( msg.to, "Admins :\n\n" + mc1 + "\nOwners :\n\n" + mc2 + "\n\nBot Login v1.0") print("[Command]Stafflist executed") #______________LOGIN WIN ____________________ elif msg.text.lower().startswith("loginwin"): if msg.from_ in creator + admin: separate = msg.text.split(" ") jmlh = int(separate[1]) for x in range(jmlh): Headers.update({'x-lpqs': '/api/v4/TalkService.do'}) transport = THttpClient.THttpClient( 'https://gd2.line.naver.jp/api/v4/TalkService.do') transport.setCustomHeaders(Headers) protocol = TCompactProtocol.TCompactProtocol(transport) client = LineService.Client(protocol) qr = client.getAuthQrcode(keepLoggedIn=1, systemName=nama1) link = "line://au/q/" + qr.verifier print(link) cl.sendText(msg.to, "Starting white true") cl.sendText(msg.to, "Except") cl.sendText(msg.to, str(link)) Headers.update({ "x-lpqs": '/api/v4/TalkService.do', 'X-Line-Access': qr.verifier }) json.loads(requests.session().get( 'https://gd2.line.naver.jp/Q', headers=Headers).text) Headers.update({'x-lpqs': '/api/v4p/rs'}) transport = THttpClient.THttpClient( 'https://gd2.line.naver.jp/api/v4p/rs') transport.setCustomHeaders(Headers) protocol = TCompactProtocol.TCompactProtocol(transport) client = LineService.Client(protocol) req = LoginRequest() req.type = 1 req.verifier = qr.verifier req.e2eeVersion = 1 res = client.loginZ(req) print('\n') print(res.authToken) else: cl.sendText(msg.to, "The bot has been mmade with header 1") cl.sendText(msg.to, str(res.authToken)) #______________LOGIN MAC____________________ elif msg.text.lower().startswith("loginmac"): if msg.from_ in creator + admin: separate = msg.text.split(" ") jmlh = int(separate[1]) for x in range(jmlh): Headers2.update({'x-lpqs': '/api/v4/TalkService.do'}) transport = THttpClient.THttpClient( 'https://gd2.line.naver.jp/api/v4/TalkService.do') transport.setCustomHeaders(Headers2) protocol = TCompactProtocol.TCompactProtocol(transport) client = LineService.Client(protocol) qr = client.getAuthQrcode(keepLoggedIn=1, systemName=nama2) link = "line://au/q/" + qr.verifier print(link) cl.sendText(msg.to, "Starting white true") cl.sendText(msg.to, "Except") cl.sendText(msg.to, str(link)) Headers2.update({ "x-lpqs": '/api/v4/TalkService.do', 'X-Line-Access': qr.verifier }) json.loads(requests.session().get( 'https://gd2.line.naver.jp/Q', headers=Headers2).text) Headers2.update({'x-lpqs': '/api/v4p/rs'}) transport = THttpClient.THttpClient( 'https://gd2.line.naver.jp/api/v4p/rs') transport.setCustomHeaders(Headers2) protocol = TCompactProtocol.TCompactProtocol(transport) client = LineService.Client(protocol) req = LoginRequest() req.type = 1 req.verifier = qr.verifier req.e2eeVersion = 1 res = client.loginZ(req) print('\n') print(res.authToken) else: cl.sendText(msg.to, "The bot has been mmade with header 2") cl.sendText(msg.to, str(res.authToken)) #_________________BYE BOT________________________ elif msg.text.lower().startswith(".@bye"): if msg.from_ in creator + admin: if msg.toType == 2: ginfo = cl.getGroup(msg.to) try: cl.sendText(msg.to, "Bye Bye " + str(ginfo.name)) cl.leaveGroup(msg.to) except: pass #________________INVITE VIA NO ____________ elif msg.text.lower().startswith(".invite "): if msg.from_ in creator + admin: nomor = msg.text.replace(".invite ", "") G = cl.getGroupIdsJoined() cgroup = cl.getGroups(G) for x in range(len(cgroup)): try: if nomor == str(x): gid = cgroup[x].id gname = cgroup[x].name cl.inviteIntoGroup(gid, [msg.from_]) cl.sendText(msg.to, "Invited to %s" % (gname)) print(gid) except Exception as error: cl.sendText(msg.to, "Failed") except: pass #________________CEK GROUP____________________ elif msg.text.lower().startswith(".groups"): if msg.from_ in creator + admin: G = cl.getGroupIdsJoined() cgroup = cl.getGroups(G) ngroup = "" for x in range(len(cgroup)): ngroup += "\n" + str( x) + " - " + cgroup[x].name + " ( " + str( len(cgroup[x].members)) + " )" pass cl.sendText( msg.to, "List Group:\n%s\n\nTotal Group: %s" % (ngroup, str(len(cgroup)))) #___________________MY GROUP______________________________ elif msg.text.lower().startswith(".mygroups"): if msg.from_ in creator: gid = cl.getGroupIdsJoined() num = 1 h = "" for i in gid: h += " %i. %s\n" % (num, cl.getGroup(i).name + " (" + str(len(cl.getGroup(i).members)) + ")") num = (num + 1) jp1 = cl.getContact(msg.from_).displayName cl.sendText( msg.to, "Groups : " + jp1 + "\n\n" + h + "\nTotal Groups = " + "" + str(len(gid)) + "") elif msg.text.lower().startswith(".leave allgroups"): if msg.from_ in creator: gid = cl.getGroupIdsJoined() for i in gid: cl.leaveGroup(i) #_________________SAY_____________________ elif msg.text.lower().startswith(".say "): if msg.from_ in creator + admin: bctxt = msg.text.replace(".say ", "") cl.sendText(msg.to, (bctxt)) #______________RESPONSENAME_________________________ elif msg.text.lower().startswith(".ping"): if msg.from_ in creator + admin: cl.sendText(msg.to, "pong") if op.type == 59: print(op) except Exception as error: print(error)
# the variables below. # then, log in as the user, and visit this url to authorize the app: ERNAME # see the /developer/apps page to register an application. username="******" password="******" email="EMAIL" repo_name="REPO_NAME" # the username of the account you are accessing app_id="APP_ID" # your app's unique id app_token="APP_TOKEN" # your app's unique token datahub_transport = THttpClient.THttpClient('http://datahub.csail.mit.edu/service') datahub_transport = TTransport.TBufferedTransport(datahub_transport) datahub_protocol = TBinaryProtocol.TBinaryProtocol(datahub_transport) datahub_client = DataHub.Client(datahub_protocol) print "Version: %s" %(datahub_client.get_version()) account_transport = THttpClient.THttpClient('http://datahub.csail.mit.edu/service/account') account_transport = TTransport.TBufferedTransport(account_transport) account_protocol = TBinaryProtocol.TBinaryProtocol(account_transport) account_client = AccountService.Client(account_protocol) print "\nTrying to query a user's table..." # RECOMMENDED (How an app should read/write in a users' repo) # Connect to the user repository through app_id + app_token. # Don't expose their password
def open(cls, connection): if connection.state == ConnectionState.OPEN: logger.debug('Connection is already open, skipping open.') return connection creds = connection.credentials exc = None for i in range(1 + creds.connect_retries): try: if creds.method == SparkConnectionMethod.HTTP: cls.validate_creds( creds, ['token', 'host', 'port', 'cluster', 'organization']) conn_url = cls.SPARK_CONNECTION_URL.format( host=creds.host, port=creds.port, organization=creds.organization, cluster=creds.cluster) logger.debug("connection url: {}".format(conn_url)) transport = THttpClient.THttpClient(conn_url) raw_token = "token:{}".format(creds.token).encode() token = base64.standard_b64encode(raw_token).decode() transport.setCustomHeaders( {'Authorization': 'Basic {}'.format(token)}) conn = hive.connect(thrift_transport=transport) handle = PyhiveConnectionWrapper(conn) elif creds.method == SparkConnectionMethod.THRIFT: cls.validate_creds(creds, ['host', 'port', 'user', 'schema']) conn = hive.connect(host=creds.host, port=creds.port, username=creds.user, auth=creds.auth, kerberos_service_name=creds. kerberos_service_name) # noqa handle = PyhiveConnectionWrapper(conn) elif creds.method == SparkConnectionMethod.ODBC: http_path = None if creds.cluster is not None: required_fields = [ 'driver', 'host', 'port', 'token', 'organization', 'cluster' ] http_path = cls.SPARK_CLUSTER_HTTP_PATH.format( organization=creds.organization, cluster=creds.cluster) elif creds.endpoint is not None: required_fields = [ 'driver', 'host', 'port', 'token', 'endpoint' ] http_path = cls.SPARK_SQL_ENDPOINT_HTTP_PATH.format( endpoint=creds.endpoint) else: raise dbt.exceptions.DbtProfileError( "Either `cluster` or `endpoint` must set when" " using the odbc method to connect to Spark") cls.validate_creds(creds, required_fields) dbt_spark_version = __version__.version user_agent_entry = f"fishtown-analytics-dbt-spark/{dbt_spark_version} (Databricks)" # noqa # https://www.simba.com/products/Spark/doc/v2/ODBC_InstallGuide/unix/content/odbc/options/driver.htm connection_str = _build_odbc_connnection_string( DRIVER=creds.driver, HOST=creds.host, PORT=creds.port, UID="token", PWD=creds.token, HTTPPath=http_path, AuthMech=3, SparkServerType=3, ThriftTransport=2, SSL=1, UserAgentEntry=user_agent_entry, ) conn = pyodbc.connect(connection_str, autocommit=True) handle = PyodbcConnectionWrapper(conn) else: raise dbt.exceptions.DbtProfileError( f"invalid credential method: {creds.method}") break except Exception as e: exc = e if isinstance(e, EOFError): # The user almost certainly has invalid credentials. # Perhaps a token expired, or something msg = 'Failed to connect' if creds.token is not None: msg += ', is your token valid?' raise dbt.exceptions.FailedToConnectException(msg) from e retryable_message = _is_retryable_error(e) if retryable_message and creds.connect_retries > 0: msg = (f"Warning: {retryable_message}\n\tRetrying in " f"{creds.connect_timeout} seconds " f"({i} of {creds.connect_retries})") logger.warning(msg) time.sleep(creds.connect_timeout) else: raise dbt.exceptions.FailedToConnectException( 'failed to connect') from e else: raise exc connection.handle = handle connection.state = ConnectionState.OPEN return connection
def Square(self, isopen=True): self.transport = THttpClient.THttpClient(self.host) self.transport.setCustomHeaders(self.headers) self.protocol = TCompactProtocol.TCompactProtocol(self.transport)
def open(cls, connection): if connection.state == ConnectionState.OPEN: logger.debug('Connection is already open, skipping open.') return connection creds = connection.credentials exc = None for i in range(1 + creds.connect_retries): try: if creds.method == 'http': cls.validate_creds( creds, ['token', 'host', 'port', 'cluster', 'organization']) conn_url = cls.SPARK_CONNECTION_URL.format( host=creds.host, port=creds.port, organization=creds.organization, cluster=creds.cluster) logger.debug("connection url: {}".format(conn_url)) transport = THttpClient.THttpClient(conn_url) raw_token = "token:{}".format(creds.token).encode() token = base64.standard_b64encode(raw_token).decode() transport.setCustomHeaders( {'Authorization': 'Basic {}'.format(token)}) conn = hive.connect(thrift_transport=transport) elif creds.method == 'thrift': cls.validate_creds(creds, ['host', 'port', 'user', 'schema']) conn = hive.connect(host=creds.host, port=creds.port, username=creds.user) else: raise dbt.exceptions.DbtProfileError( f"invalid credential method: {creds.method}") break except Exception as e: exc = e if getattr(e, 'message', None) is None: raise dbt.exceptions.FailedToConnectException(str(e)) message = e.message.lower() is_pending = 'pending' in message is_starting = 'temporarily_unavailable' in message warning = "Warning: {}\n\tRetrying in {} seconds ({} of {})" if is_pending or is_starting: msg = warning.format(e.message, creds.connect_timeout, i, creds.connect_retries) logger.warning(msg) time.sleep(creds.connect_timeout) else: raise dbt.exceptions.FailedToConnectException(str(e)) else: raise exc handle = ConnectionWrapper(conn) connection.handle = handle connection.state = ConnectionState.OPEN return connection
def open(cls, connection): if connection.state == ConnectionState.OPEN: logger.debug('Connection is already open, skipping open.') return connection creds = connection.credentials exc = None for i in range(1 + creds.connect_retries): try: if creds.method == 'http': cls.validate_creds( creds, ['token', 'host', 'port', 'cluster', 'organization']) conn_url = cls.SPARK_CONNECTION_URL.format( host=creds.host, port=creds.port, organization=creds.organization, cluster=creds.cluster) logger.debug("connection url: {}".format(conn_url)) transport = THttpClient.THttpClient(conn_url) raw_token = "token:{}".format(creds.token).encode() token = base64.standard_b64encode(raw_token).decode() transport.setCustomHeaders( {'Authorization': 'Basic {}'.format(token)}) conn = hive.connect(thrift_transport=transport) elif creds.method == 'thrift': cls.validate_creds(creds, ['host', 'port', 'user', 'schema']) conn = hive.connect(host=creds.host, port=creds.port, username=creds.user) else: raise dbt.exceptions.DbtProfileError( f"invalid credential method: {creds.method}") break except Exception as e: exc = e if isinstance(e, EOFError): # The user almost certainly has invalid credentials. # Perhaps a token expired, or something msg = 'Failed to connect' if creds.token is not None: msg += ', is your token valid?' raise dbt.exceptions.FailedToConnectException(msg) from e retryable_message = _is_retryable_error(e) if retryable_message: msg = (f"Warning: {retryable_message}\n\tRetrying in " f"{creds.connect_timeout} seconds " f"({i} of {creds.connect_retries})") logger.warning(msg) time.sleep(creds.connect_timeout) else: raise dbt.exceptions.FailedToConnectException( 'failed to connect') from e else: raise exc handle = ConnectionWrapper(conn) connection.handle = handle connection.state = ConnectionState.OPEN return connection
def LineShake(self, host, headers): transport = THttpClient.THttpClient(host) transport.setCustomHeaders(headers) protocol = TCompactProtocol.TCompactProtocol(transport) return self.Client(protocol)
def qrLogin(): #Update Headers pertama Headers.update({'x-lpqs': '/api/v4/TalkService.do'}) #membentuk Transport transport = THttpClient.THttpClient( 'https://gd2.line.naver.jp/api/v4/TalkService.do') transport.setCustomHeaders(Headers) #membentuk Protokol protocol = TCompactProtocol.TCompactProtocol(transport) #membuat client pertama client = LineService.Client(protocol) #mengambil QR Code qr = client.getAuthQrcode(keepLoggedIn=1, systemName=nama) #Hasil : (qrcode=u'data:image/jpeg;base64, BlaBlaBla, verifier=u'32digit' #ambil qr.verifier 32digit dan print untuk proses Login link = "line://au/q/" + qr.verifier print(link) #:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-# #:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-# #Update Headers kedua Headers.update({ "x-lpqs": '/api/v4/TalkService.do', 'X-Line-Access': qr.verifier }) #membuntuk Session json.loads(requests.session().get('https://gd2.line.naver.jp/Q', headers=Headers).text) #Hasil : {u'timestamp': u'1522246627842', u'result': {u'verifier': u'32digit', u'authPhase': u'QRCODE_VERIFIED', u'metadata': {}}} #:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-# #:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-# #Update Headers ketiga Headers.update({'x-lpqs': '/api/v4p/rs'}) #membuat client kedua transport = THttpClient.THttpClient('https://gd2.line.naver.jp/api/v4p/rs') transport.setCustomHeaders(Headers) protocol = TCompactProtocol.TCompactProtocol(transport) client = LineService.Client(protocol) #membuat parameter LoginRequest req = LoginRequest() req.type = 1 req.verifier = qr.verifier req.e2eeVersion = 1 #Hasil : (identifier=None, identityProvider=None, certificate=None, e2eeVersion=1, secret=None, keepLoggedIn=None, verifier=u'32digit', systemName=None, accessLocation=None, password=None, type=1) #Proses Login res = client.loginZ(req) #Hasil : (authToken=u'HasilToken', displayMessage=None, certificate=u'Sertifikat', sessionForSMSConfirm=None, pinCode=None, verifier=None, lastPrimaryBindTime=1521439494501L, type=1) #Cetak Token print('\n') print(res.authToken)
# presumes access to create and use tables in a namespace 'test' # # usage: # ./demo_hbase_thrift_over_http_tls.py host-running-thrift1.example.com import sys from thrift import Thrift from thrift.transport import THttpClient from thrift.protocol import TBinaryProtocol from hbase import Hbase from hbase.ttypes import ColumnDescriptor from hbase.ttypes import Mutation from hbase.ttypes import IOError as HBaseIOError print "[INFO] setup connection" transport = THttpClient.THttpClient("https://{0}:{1}".format( sys.argv[1], 9090)) client = Hbase.Client(TBinaryProtocol.TBinaryProtocol(transport)) table = 'test:thrift_proxy_demo' print "[INFO] start client" transport.open() print "[INFO] list the current tables" print client.getTableNames() print "[INFO] create a table, place some data" client.createTable(table, [ColumnDescriptor(name='family1:')]) client.mutateRow(table, 'row1', [ Mutation(column='family1:cq1', value='foo'), Mutation(column='family1:cq2', value='foo')
username = sys.argv[1] password = sys.argv[2] # # NOTE: You must change the consumer key and consumer secret to the # key and secret that you received from Evernote # consumerKey = "westine" consumerSecret = "277e8b3a8cc49b2d" evernoteHost = "www.evernote.com" #this is production service userStoreUri = "https://" + evernoteHost + "/edam/user" noteStoreUriBase = "https://" + evernoteHost + "/edam/note/" userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol(userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) versionOK = userStore.checkVersion("Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) print "Is my EDAM protocol version up to date? ", str(versionOK) print "" if not versionOK: exit(1) # Authenticate the user try: authResult = userStore.authenticate(username, password, consumerKey,
def tokenLogin(self): self.transport = THttpClient.THttpClient(self.LINE_HTTP_URL) self.transport.setCustomHeaders(self._headers) self.protocol = TCompactProtocol.TCompactProtocol(self.transport) self._client = CurveThrift.Client(self.protocol)
def login(self, keepLoggedIn=True, systemName=com_name): """Login to LINE server.""" #TalkService self.transport = THttpClient.THttpClient(self.LINE_AUTH_QUERY_PATH) self.transport.setCustomHeaders(self._headers) self.protocol = TCompactProtocol.TCompactProtocol(self.transport) self._client = TalkService.Client(self.protocol) #AuthService self.transport = THttpClient.THttpClient(self.LINE_LOGIN_QUERY_PATH) self.transport.setCustomHeaders(self._headers) self.protocol = TCompactProtocol.TCompactProtocol(self.transport) self._auth = AuthService.Client(self.protocol) self.provider = IdentityProvider.LINE rsaKey = self._client.getRSAKeyInfo(self.provider) message = (chr(len(rsaKey.sessionKey)) + rsaKey.sessionKey + chr(len(_id)) + _id + chr(len(passwd)) + passwd).encode('utf-8') pub_key = rsa.PublicKey(int(rsaKey.nvalue, 16), int(rsaKey.evalue, 16)) crypto = rsa.encrypt(message, pub_key).hex() try: with open(self.CERT_FILE, 'r') as f: self.certificate = f.read() f.close() except: self.certificate = "" lReq = self.loginRequest( '0', { 'identityProvider': self.provider, 'identifier': rsaKey.keynm, 'password': crypto, 'keepLoggedIn': keepLoggedIn, 'accessLocation': '127.0.0.1', 'systemName': systemName, 'certificate': self.certificate, 'e2eeVersion': 0 }) result = self._auth.loginZ(lReq) if result.type == LoginResultType.REQUIRE_DEVICE_CONFIRM: if withReturn == False: print('Enter Pincode: "{}"'.format(result.pinCode)) self._headers['X-Line-Access'] = result.verifier getAccessKey = self.get_json(self.LINE_DOMAIN + '/Q') self.verifier = result.verifier self.pinCode = result.pinCode try: lReq = self.loginRequest( '1', { 'keepLoggedIn': keepLoggedIn, 'verifier': getAccessKey['result']['verifier'], 'e2eeVersion': 0 }) result = self._auth.loginZ(lReq) except Exception as e: self.raise_error(e) if result.type == LoginResultType.SUCCESS: if result.certificate is not None: with open(self.CERT_FILE, 'w') as f: f.write(result.certificate) self.certificate = result.certificate if result.authToken is not None: self.authToken = self._headers[ 'X-Line-Access'] = result.authToken else: return False else: return self.raise_error('Login failed') else: return (result, 'Enter Pincode: "{}"'.format(result.pinCode)) elif result.type == LoginResultType.REQUIRE_QRCODE: self.qrLogin(systemName=self.com_name, APP_NAME=self.app_name) pass elif result.type == LoginResultType.SUCCESS: if result.authToken is not None: self.certificate = result.certificate self.authToken = self._headers[ 'X-Line-Access'] = result.authToken else: return False else: raise Exception('Login Failed')
def _get_client_by_url(self): config = self.config url = urlparse(config.url) host, port = self._parse_host_port(url[1], 80) transport = THttpClient.THttpClient(config.url) return self._get_client_by_transport(config, transport)