def __init__(self):
self._session = requests.session()
self._session.headers.update({'User-Agent': 'Niantic App'})
self._session.verify = True
self.auth_provider = None
self._curl = ParallelCurl({pycurl.FOLLOWLOCATION: 1, pycurl.MAXREDIRS: 5, pycurl.TIMEOUT: 10,
pycurl.NOSIGNAL: 1, pycurl.USERAGENT: 'Niantic App',
pycurl.ENCODING: 'gzip,deflate', pycurl.CAINFO: certifi.where()}, 8)
def __init__(self):
self._session = requests.session()
self._session.headers.update({'User-Agent': 'Niantic App'})
self._session.verify = True
self.auth_provider = None
pycurl_options = {pycurl.FOLLOWLOCATION: 1, pycurl.MAXREDIRS: 5,
pycurl.NOSIGNAL: 1, pycurl.USERAGENT: 'Niantic App',
pycurl.CONNECTTIMEOUT: 10000,
pycurl.CAINFO: certifi.where()}
try:
pycurl.Curl().setopt(pycurl.DNS_SERVERS, "8.8.8.8")
# If the above line does not fail, DNS is available
pycurl_options[pycurl.DNS_SERVERS] = "8.8.8.8"
except:
pass # Just use default DNS Server
self._curl = ParallelCurl(pycurl_options, 8)
class RpcApi:
def __init__(self):
self._session = requests.session()
self._session.headers.update({'User-Agent': 'Niantic App'})
self._session.verify = True
self.auth_provider = None
pycurl_options = {pycurl.FOLLOWLOCATION: 1, pycurl.MAXREDIRS: 5,
pycurl.NOSIGNAL: 1, pycurl.USERAGENT: 'Niantic App',
pycurl.CONNECTTIMEOUT: 10000,
pycurl.CAINFO: certifi.where()}
try:
pycurl.Curl().setopt(pycurl.DNS_SERVERS, "8.8.8.8")
# If the above line does not fail, DNS is available
pycurl_options[pycurl.DNS_SERVERS] = "8.8.8.8"
except:
pass # Just use default DNS Server
self._curl = ParallelCurl(pycurl_options, 8)
def get_rpc_id(self):
return 8145806132888207460
def decode_raw(self, raw):
process = subprocess.Popen(['protoc', '--decode_raw'], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
output = error = None
try:
output, error = process.communicate(raw)
except:
pass
return output
def _make_rpc(self, endpoint, request_proto_plain):
log.debug('Execution of RPC')
request_proto_serialized = request_proto_plain.SerializeToString()
try:
http_response = self._session.post(endpoint, data=request_proto_serialized, timeout=10)
except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
raise ServerBusyOrOfflineException
return http_response
def request(self, endpoint, subrequests, player_position):
if not self.auth_provider or self.auth_provider.is_login() is False:
raise NotLoggedInException()
request_proto = self._build_main_request(subrequests, player_position)
response = self._make_rpc(endpoint, request_proto)
response_dict = parse_main_request(response.content, response.status_code, subrequests)
return response_dict
def request_async(self, endpoint, subrequests, player_position, callback):
if not self.auth_provider or self.auth_provider.is_login() is False:
raise NotLoggedInException()
request_proto = self._build_main_request(subrequests, player_position)
request_proto_serialized = request_proto.SerializeToString()
bundle = {'callback': callback, 'subrequests': subrequests}
self._curl.add_request({pycurl.URL: endpoint, pycurl.POSTFIELDS: request_proto_serialized},
self._success_callback, self._error_callback, bundle=bundle)
def _success_callback(self, handle, options, bundle, header_buf, data_buf):
response_data = data_buf.getvalue()
response_dict = parse_main_request(response_data, 200, bundle['subrequests'])
bundle['callback'](response_dict)
def _error_callback(self, handle, options, bundle, header_buf, data_buf):
log.warning("Error downloading map: {}".format(handle.getinfo(pycurl.RESPONSE_CODE)))
bundle['callback'](False)
def _build_main_request(self, subrequests, player_position=None):
log.debug('Generating main RPC request...')
request = RpcEnvelope.Request()
request.direction = RpcEnum.REQUEST
request.rpc_id = self.get_rpc_id()
if player_position is not None:
request.latitude, request.longitude, request.altitude = player_position
# ticket = self._auth_provider.get_ticket()
# if ticket:
# request.auth_ticket.expire_timestamp_ms, request.auth_ticket.start, request.auth_ticket.end = ticket
# else:
request.auth.provider = self.auth_provider.get_name()
request.auth.token.contents = self.auth_provider.get_token()
request.auth.token.unknown13 = 59
# unknown stuff
request.unknown12 = 989
request = build_sub_requests(request, subrequests)
log.debug('Generated protobuf request: \n\r%s', request)
return request
def finish_async(self, max_time=None):
self._curl.finish_requests(max_time)
