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)
