def test_latest():
client = Client(schema=schema, parse_results=True)
now = datetime.fromisoformat("2021-11-12T11:58:13.461161")
in_five_days = datetime.fromisoformat("2021-11-17T11:58:13.461161")
query = gql("query latest($times: [Datetime!]!) {latest(times: $times)}")
variable_values = {
"times": [now, in_five_days],
}
result = client.execute(query,
variable_values=variable_values,
serialize_variables=True)
print(result)
assert result["latest"] == in_five_days
def get_apod_client():
""" Gets the client to access the API wrapper and caches it """
config = get_client_cfg()
hook = get_hook()
transport = AIOHTTPTransport(url=config['endpoint'])
gql_client = Client(transport=transport, fetch_schema_from_transport=True)
return ApodClient(config=config,
hook=hook,
transport=transport,
gql_client=gql_client)
async def test_websocket_server_does_not_ack(event_loop, server):
from gql.transport.websockets import WebsocketsTransport
url = f"ws://{server.hostname}:{server.port}/graphql"
print(f"url = {url}")
sample_transport = WebsocketsTransport(url=url)
with pytest.raises(TransportProtocolError):
async with Client(transport=sample_transport):
pass
async def test_phoenix_channel_query_error(event_loop, server, query_str):
path = "/graphql"
url = f"ws://{server.hostname}:{server.port}{path}"
sample_transport = PhoenixChannelWebsocketsTransport(
channel_name="test_channel", url=url)
query = gql(query_str)
with pytest.raises(TransportQueryError):
async with Client(transport=sample_transport) as session:
await session.execute(query)
def client(self):
if self._client is None:
transport = \
RequestsHTTPTransport(self.url, use_json=True, timeout=300)
transport.headers = {
'User-Agent': 'sierra-client (python)/{}'.format(VERSION)
}
self._client = Client(
transport=transport,
fetch_schema_from_transport=True)
return self._client
def launch_pipeline_over_graphql(
location, repo_name, pipeline_name, run_config, mode, url="http://localhost:3000/graphql"
):
transport = RequestsHTTPTransport(url=url)
client = Client(transport=transport, fetch_schema_from_transport=True)
# end_trigger_marker_0
query = LAUNCH_PIPELINE_EXECUTION_MUTATION
params = {
"executionParams": {
"selector": {
"repositoryLocationName": location,
"repositoryName": repo_name,
"pipelineName": pipeline_name,
},
"runConfigData": run_config,
"mode": mode,
}
}
return client.execute(gql(query), variable_values=params)
async def subscribe_messages(self) -> AsyncIterator[str]:
"""Subscribe to job messages"""
s = gql(f"""
subscription {{
subscribeJobMessages(jobId: "{self.job_id}")
}}
""")
async with Client(transport=self.client.ws_transport,
schema=self.client.schema) as sess:
async for result in sess.subscribe(s):
yield result["subscribeJobMessages"]
def __init__(self, account_id, api_key, region="us"):
try:
self.account_id = int(account_id)
except ValueError:
raise ValueError("Account ID must be an integer")
self.api_key = api_key
if region == "us":
self.url = "https://api.newrelic.com/graphql"
elif region == "eu":
self.url = "https://api.eu.newrelic.com/graphql"
else:
raise ValueError("Region must be one of 'us' or 'eu'")
transport = RequestsHTTPTransport(url=self.url, use_json=True)
transport.headers = {"api-key": self.api_key}
self.client = Client(transport=transport,
fetch_schema_from_transport=True)
def __init__(self, client_id, client_secret):
data = "grant_type=client_credentials"
buffer = BytesIO()
crl = pycurl.Curl()
crl.setopt(pycurl.POST, 1)
crl.setopt(pycurl.POSTFIELDS, data)
crl.setopt(pycurl.URL, v2_oauth_transport.api_token_url)
crl.setopt(pycurl.USERPWD, "{}:{}".format(client_id, client_secret))
crl.setopt(pycurl.WRITEDATA, buffer)
crl.perform()
self.token = json.loads(buffer.getvalue())["access_token"]
auth_header = "Bearer {}".format(self.token)
header = {"Authorization": auth_header}
transport = RequestsHTTPTransport(url=self.api_url, headers=header)
self.client = Client(transport=transport,
fetch_schema_from_transport=True)
async def test_async_client_validation_different_schemas_parameters_forbidden(
event_loop, server, subscription_str, client_params
):
url = f"ws://{server.hostname}:{server.port}/graphql"
sample_transport = WebsocketsTransport(url=url)
with pytest.raises(AssertionError):
async with Client(transport=sample_transport, **client_params):
pass
def client(self):
if self._client is None:
transport = \
RequestsHTTPTransportWOrderedDict(self.url, timeout=300)
transport.headers = {
'Content-Type': 'application/json',
'User-Agent': 'sierra-client (python)/{}'.format(VERSION)
}
self._client = Client(transport=transport,
fetch_schema_from_transport=True)
return self._client
async def test_websocket_add_extra_parameters_to_connect(event_loop, server):
url = f"ws://{server.hostname}:{server.port}/graphql"
# Increase max payload size to avoid websockets.exceptions.PayloadTooBig exceptions
sample_transport = WebsocketsTransport(url=url, connect_args={"max_size": 2 ** 21})
query = gql(query1_str)
async with Client(transport=sample_transport) as session:
await session.execute(query)
def test_code():
transport = RequestsHTTPTransport(url=url)
with Client(transport=transport) as session:
query = gql(query1_str)
with pytest.raises(TransportServerError) as exc_info:
session.execute(query)
assert "401 Client Error: Unauthorized" in str(exc_info.value)
def get_graphql_client(graphql_token: str) -> Client:
headers = {
"User-Agent":
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36",
"Authorization": graphql_token,
}
return Client(transport=RequestsHTTPTransport(url=MYENERGY_GRAPHQL_URL,
headers=headers,
timeout=TIMEOUT_S),
# fetch_schema_from_transport=True,
)
def test_http_transport_raise_for_status_error(http_transport_query):
with Client(
transport=RequestsHTTPTransport(
url="https://countries.trevorblades.com/",
use_json=False,
headers={"Content-type": "application/json"},
)
) as client:
with pytest.raises(Exception) as exc_info:
client.execute(http_transport_query)
assert "400 Client Error: Bad Request for url" in str(exc_info.value)
async def test_websocket_server_does_not_send_ack(event_loop, server,
query_str):
from gql.transport.websockets import WebsocketsTransport
url = f"ws://{server.hostname}:{server.port}/graphql"
sample_transport = WebsocketsTransport(url=url, ack_timeout=1)
with pytest.raises(asyncio.TimeoutError):
async with Client(transport=sample_transport):
pass
def fetch_data_from_web(filter_criterion):
sample_transport=RequestsHTTPTransport(
url=GRAPHQL_URL,
retries=3,
)
client = Client(
transport=sample_transport,
fetch_schema_from_transport=True,
)
# (filter: {{ratio: {{lessThan: "{unsafe_ratio}"}}, art: {{greaterThanOrEqualTo: "{min_debt}"}}}})
# allCupActs (filter: {{time: {{lessThan: "2020-03-16", greaterThan: "2020-03-03"}}}}) # actions_data.txt
query_string = """
query {{
allCupActs (filter: {filter_criterion}) {{
totalCount
nodes {{
id
act
arg
lad
art
block
deleted
ink
ire
pip
tab
ratio
time
tx
}}
}}
}}
""".format(filter_criterion=filter_criterion)
logger.info(query_string)
query = gql(query_string)
return client.execute(query)
def __init__(self, default_settings=None, load_settings=True, retry_timedelta=datetime.timedelta(days=1), environ=os.environ):
self._environ = environ
self.default_settings = {
'section': "default",
'run': "latest",
'git_remote': "origin",
'ignore_globs': [],
'base_url': "https://api.wandb.ai"
}
self.retry_timedelta = retry_timedelta
self.default_settings.update(default_settings or {})
self.retry_uploads = 10
self._settings = Settings(load_settings=load_settings)
#self.git = GitRepo(remote=self.settings("git_remote"))
self.git = None
# Mutable settings set by the _file_stream_api
self.dynamic_settings = {
'system_sample_seconds': 2,
'system_samples': 15,
'heartbeat_seconds': 30,
}
self.client = Client(
transport=RequestsHTTPTransport(
headers={
'User-Agent': self.user_agent,
'X-WANDB-USERNAME': env.get_username(env=self._environ),
'X-WANDB-USER-EMAIL': env.get_user_email(env=self._environ)},
use_json=True,
# this timeout won't apply when the DNS lookup fails. in that case, it will be 60s
# https://bugs.python.org/issue22889
timeout=self.HTTP_TIMEOUT,
auth=("api", self.api_key or ""),
url='%s/graphql' % self.settings('base_url')
)
)
self.gql = retry.Retry(self.execute,
retry_timedelta=retry_timedelta,
check_retry_fn=util.no_retry_auth,
retryable_exceptions=(RetryError, requests.RequestException))
self._current_run_id = None
self._file_stream_api = None
def perform_tournament_info_api_call(event_id, tournament_id, entrant_id):
sample_transport = RequestsHTTPTransport(
url='https://api.smash.gg/gql/alpha',
use_json=True,
headers={
"Content-type": "application/json",
'Authorization': "Bearer {}".format(authToken)
})
client = Client(
retries=3,
transport=sample_transport,
fetch_schema_from_transport=True,
)
query1 = gql('''
query EventEntrants($eventId: ID!) {
event(id: $eventId) {
id
name
tournament {
id
name
state
}
phases {
id
name
bracketType
phaseGroups {
nodes {
id
displayIdentifier
state
}
}
}
}
},
''')
variables = {"eventId": event_id}
results = client.execute(query1, variables)
return results
def perform_entrants_api_call(event_id, tournament_id):
sample_transport = RequestsHTTPTransport(
url='https://api.smash.gg/gql/alpha',
use_json=True,
headers={
"Content-type": "application/json",
'Authorization': "Bearer {}".format(authToken)
})
client = Client(
retries=3,
transport=sample_transport,
fetch_schema_from_transport=True,
)
query1 = gql('''
query EventEntrants($eventId: ID!, $page: Int!, $perPage: Int!) {
event(id: $eventId) {
id
name
entrants(query: {
page: $page
perPage: $perPage
}) {
pageInfo {
total
totalPages
}
nodes {
id
participants {
id
gamerTag
prefix
}
}
}
}
},
''')
variables = {"eventId": int(event_id), "page": 1, "perPage": 900}
results = client.execute(query1, variables)
return results
async def test_websocket_server_closing_directly(event_loop, server):
import websockets
from gql.transport.websockets import WebsocketsTransport
url = f"ws://{server.hostname}:{server.port}/graphql"
print(f"url = {url}")
sample_transport = WebsocketsTransport(url=url)
with pytest.raises(websockets.exceptions.ConnectionClosed):
async with Client(transport=sample_transport):
pass
def test_opposite_color_variable_serialized_manually():
client = Client(schema=schema, parse_results=True)
query = gql("""
query GetOppositeColor($color: Color) {
opposite(color:$color)
}""")
variable_values = {
"color": "RED",
}
result = client.execute(query, variable_values=variable_values)
print(result)
opposite_color = result["opposite"]
assert isinstance(opposite_color, Color)
assert opposite_color == CYAN
def json_req_graphql():
_transport = RequestsHTTPTransport(
url='https://graphql-pokemon.now.sh/',
use_json=True,
)
client = Client(
transport=_transport,
fetch_schema_from_transport=True,
)
query = gql("""
{
pokemon(name: "Pikachu") {
attacks {
special {
name
}
}
}
}
""")
return client.execute(query)
def owner(self, request, *args, **kwargs):
sample_transport = RequestsHTTPTransport(
url=get_subgraph_endpoint(),
verify=True,
retries=3,
)
client = Client(transport=sample_transport)
query_string = '''
query {
autographs(where:{%s}) {
id
owner
creators
imageURI
metadataURI
}
}''' % '''owner:"{}"'''.format(kwargs['owner'])
query = gql(query_string)
response = client.execute(query)
serializer = AutographSerializer(response['autographs'], many=True)
return Response(serializer.data)
async def client_and_server(server):
"""Helper fixture to start a server and a client connected to its port."""
# Generate transport to connect to the server fixture
path = "/graphql"
url = f"ws://{server.hostname}:{server.port}{path}"
sample_transport = WebsocketsTransport(url=url)
async with Client(transport=sample_transport) as session:
# Yield both client session and server
yield session, server
def test_http_transport_verify_error(http_transport_query):
from gql.transport.requests import RequestsHTTPTransport
with Client(transport=RequestsHTTPTransport(
url="https://countries.trevorblades.com/",
verify=False,
)) as client:
with pytest.warns(Warning) as record:
client.execute(http_transport_query)
assert len(record) == 1
assert "Unverified HTTPS request is being made to host" in str(
record[0].message)
def test_shift_days():
client = Client(schema=schema,
parse_results=True,
serialize_variables=True)
now = datetime.fromisoformat("2021-11-12T11:58:13.461161")
query = gql(
"query shift5days($time: Datetime) {shiftDays(time: $time, days: 5)}")
variable_values = {
"time": now,
}
result = client.execute(query, variable_values=variable_values)
print(result)
assert result["shiftDays"] == datetime.fromisoformat(
"2021-11-17T11:58:13.461161")
def setupConnection(self):
transport = RequestsHTTPTransport(
url="https://anantara.hasura.app/v1/graphql",
verify=True,
retries=3,
headers={
"content-type": "application/json",
"Authorization": "Bearer {}".format(self.cookie),
},
)
self.__client = Client(transport=transport,
fetch_schema_from_transport=True)
def test_execute_result_error():
client = Client(
transport=RequestsHTTPTransport(url="https://countries.trevorblades.com/"),
)
failing_query = gql(
"""
query getContinents {
continents {
code
name
id
}
}
"""
)
with pytest.raises(Exception) as exc_info:
client.execute(failing_query)
assert 'Cannot query field "id" on type "Continent".' in str(exc_info.value)
async def test_websocket_server_sending_invalid_query_errors(
event_loop, server):
from gql.transport.websockets import WebsocketsTransport
url = f"ws://{server.hostname}:{server.port}/graphql"
print(f"url = {url}")
sample_transport = WebsocketsTransport(url=url)
# Invalid server message is ignored
async with Client(transport=sample_transport):
await asyncio.sleep(2 * MS)
def test_retries(execute_mock):
expected_retries = 3
execute_mock.side_effect =Exception("fail")
client = Client(
retries=expected_retries,
transport=RequestsHTTPTransport(url='http://swapi.graphene-python.org/graphql')
)
query = gql('''
{
myFavoriteFilm: film(id:"RmlsbToz") {
id
title
episodeId
}
}
''')
with pytest.raises(Exception):
client.execute(query)
assert execute_mock.call_count == expected_retries
