def _async_response_handler(request_id: int, response_data: TCStringData,
response_type: int, finished: bool):
""" Core response handler """
logging.debug(
f'Request: {request_id}; Response: {response_data.json}; '
f'Response type: {response_type}; Finished: {finished}')
request = TonModule._async_response_map.get(request_id)
if not request:
return
if finished:
del TonModule._async_response_map[request_id]
if response_type == TCResponseType.Success:
# Check if client is asyncio or common
if request['is_async']:
request['loop'].call_soon_threadsafe(
request['future'].set_result, response_data.json)
else:
request['future'].set_result(response_data.json)
return
if response_type == TCResponseType.Error:
exception = TonException(error=ClientError(**response_data.json))
# Check if client is asyncio or common
if request['is_async']:
request['loop'].call_soon_threadsafe(
request['future'].set_exception, exception)
else:
request['future'].set_exception(exception)
return
if request['callback'] and response_data.json:
args = [response_data.json, response_type, request.get('loop')]
request['callback'](*args)
def create_context(config: Dict[str, Dict[str, Union[str, int, float]]]):
response_ptr = tc_create_context(config=config)
response = TCSyncResponseData(tc_read_string(string=response_ptr))
is_success, result, error = (response.is_success, response.result,
response.error)
tc_destroy_string(response_ptr)
if not is_success:
raise TonException(error=error)
return TCClientContext(result)
def create_context(config: ClientConfig):
response_ptr = tc_create_context(config=config.dict)
response = TCSyncResponseData(tc_read_string(string=response_ptr))
is_success, result, error = (response.is_success, response.result,
response.error)
tc_destroy_string(response_ptr)
if not is_success:
raise TonException(error=ClientError(**error))
return TCClientContext(result)
def _async_response_resolver(self, request_id: int) -> Any:
read_len = 0
resolved = None
while True:
time.sleep(0.0001)
responses = self._async_response_map[request_id][read_len:]
read_len += len(responses)
for item in responses:
if item['response_type'] == TCResponseType.Error:
del self._async_response_map[request_id]
raise TonException(item['response_data'])
if item['response_type'] == TCResponseType.Success:
resolved = item['response_data']
if item['finished']:
del self._async_response_map[request_id]
return resolved
def _sync_core_request(self, method: str, request_params: str) -> Any:
""" Perform core synchronous request """
# Make sync request, get response pointer and parse it
response_ptr = tc_request_sync(
ctx=self._client.ctx, method=method, params_json=request_params)
response = TCSyncResponseData(tc_read_string(string=response_ptr))
# Copy response data and destroy response pointer
is_success, result, error = (
response.is_success, response.result, response.error)
tc_destroy_string(string=response_ptr)
if not is_success:
raise TonException(error=error)
return result
async def _async_response_generator_coro(self, request_id: int) -> Any:
read_len = 0
while True:
await asyncio.sleep(0.0001)
responses = self._async_response_map[request_id][read_len:]
read_len += len(responses)
try:
for item in responses:
if item['response_type'] == TCResponseType.Error:
del self._async_response_map[request_id]
raise TonException(item['response_data'])
if item['finished']:
del self._async_response_map[request_id]
if item['response_data']:
yield item
return
yield item
except GeneratorExit:
del self._async_response_map[request_id]
return
def __callback(response_data, response_type, *args):
if response_type == SubscriptionResponseType.OK:
result = ResultOfSubscription(**response_data)
results.append(result.result)
if response_type == SubscriptionResponseType.ERROR:
raise TonException(error=ClientError(**response_data))