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