def test_code(): sample_transport = RequestsHTTPTransport(url=url) query = gql(query1_str) with pytest.raises(TransportClosed): sample_transport.execute(query)
def create_gql_client(token): transport = RequestsHTTPTransport(url='https://api.github.com/graphql', use_json=True) transport.headers = {"Authorization": "Bearer {}".format(token)} client = Client(transport=transport) return client
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" elif region == "staging": self.url = "https://staging-api.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} try: self.client = Client(transport=transport, fetch_schema_from_transport=True) except Exception: self.client = Client(transport=transport, fetch_schema_from_transport=False)
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 __init__(self, key, secret, access_token, access_secret, etherscan_api_key, trade_value_threshold=250000, short_position_value_threshold=100000, eye_catcher_threshold=1000000, debug=False): auth = OAuthHandler(key, secret) auth.set_access_token(access_token, access_secret) self.api = API(auth) self.etherscan_api_key = etherscan_api_key # Trades transport = RequestsHTTPTransport( url=EXCHANGE_SUBGRAPH_API_ENDPOINT, verify=True, retries=3, ) self.gql_client_synthetix_exchanges = Client( transport=transport, fetch_schema_from_transport=True) # Cross-asset Swaps transport = RequestsHTTPTransport( url=CURVE_SUBGRAPH_API_ENDPOINT, verify=True, retries=3, ) self.gql_client_curve = Client(transport=transport, fetch_schema_from_transport=True) # Short positions transport = RequestsHTTPTransport( url=SHORTS_SUBGRAPH_API_ENDPOINT, verify=True, retries=3, ) self.gql_client_synthetix_shorts = Client( transport=transport, fetch_schema_from_transport=True) # CoinGecko self.cg = CoinGeckoAPI() self.trade_value_threshold = trade_value_threshold self.short_position_value_threshold = short_position_value_threshold self.eye_catcher_threshold = eye_catcher_threshold self.timestamp_last_fetch = int(time.time()) self.debug = debug
def __init__(self, username, password, year): self.username = username self.password = password self.year = year self.gql_unauthenticated_client = Client( transport=RequestsHTTPTransport(_graphql_url()), fetch_schema_from_transport=True, ) self.gql_client = Client( transport=RequestsHTTPTransport( _graphql_url(), headers={"authorization": self._token()}), fetch_schema_from_transport=True, )
def main(remote, remote_authorization, host, port, debug=False, debug_sql=False, setup_db=False): if debug: logging.basicConfig(level=logging.DEBUG) if debug_sql: logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO) if setup_db: from datasub.monitoring.database import engine from datasub.monitoring.models import Base Base.metadata.create_all(bind=engine) headers = {} if remote_authorization is not None: headers['Authorization'] = remote_authorization client = datasub.monitoring.gql.Client( transport=RequestsHTTPTransport( url=remote, headers=headers, use_json=True, ), fetch_schema_from_transport=True, ) schema = make_remote_executable_schema(client.schema, client) app = datasub.app.create(schema) app.run(host=host, port=port, debug=debug)
def __init__(self, overrides={}): self.settings = { 'entity': None, 'project': None, 'run': "latest", 'base_url': env.get_base_url("https://api.wandb.ai") } self.settings.update(overrides) if 'username' in overrides and 'entity' not in overrides: wandb.termwarn( 'Passing "username" to Api is deprecated. please use "entity" instead.' ) self.settings['entity'] = overrides['username'] self._projects = {} self._runs = {} self._sweeps = {} self._base_client = Client(transport=RequestsHTTPTransport( headers={ 'User-Agent': self.user_agent, 'Use-Admin-Privileges': "true" }, 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), url='%s/graphql' % self.settings['base_url'])) self._client = RetryingClient(self._base_client)
def do_GET(self): self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() client = Client( transport=RequestsHTTPTransport( url='https://graphql.fauna.com/graphql', headers={ 'Authorization': 'Bearer ' + getenv("FAUNADB_SECRET") }, use_json=True, ), fetch_schema_from_transport=True, ) query = gql(""" { findClientByID(id: "258719855966945812") { email } } """) self.wfile.write(json.dumps(client.execute(query)).encode('utf-8')) return
def ConvertTimeStampsToBlocks(timestamps): blocks = [None] * (len(timestamps)) # eth block api sample_transport_ETH = RequestsHTTPTransport( url= 'https://api.thegraph.com/subgraphs/name/blocklytics/ethereum-blocks', verify=True, retries=5, ) client_ETH = Client(transport=sample_transport_ETH) for i in range(0, len(timestamps)): params_name = {"timestamp_gt": timestamps[i]} block = gql(""" query($timestamp_gt: BigInt! ) { blocks(first: 1, orderBy: timestamp, orderDirection: asc, where: {timestamp_gt: $timestamp_gt}) { id number timestamp } }""") block_data = client_ETH.execute(block, variable_values=params_name) blocks[i] = int(block_data['blocks'][0]['number']) return blocks
def update_intended_process_states(self, name, running=False): try: access_token = create_access_token(identity=current_user) transport = RequestsHTTPTransport( url=GRAPHQL_URI, use_json=True, headers={ "Content-Type": "application/json; charset=utf-8", "Authorization": "Bearer {}".format(access_token), }, verify=False, ) client = Client(retries=3, transport=transport, fetch_schema_from_transport=True) query = gql(intended_process_states_mutation) params = {"name": name, "running": running} client.execute(query, variable_values=params) except Exception: log.exception("exception")
def signal_loading(module, status=False): if GUI_ENABLED != "true": return try: transport = RequestsHTTPTransport( url=GRAPHQL_URI, use_json=True, headers={ "Content-type": "application/json; charset=utf-8", "x-hasura-admin-secret": HASURA_GRAPHQL_ACCESS_KEY, }, verify=False, ) client = Client(retries=3, transport=transport, fetch_schema_from_transport=True) query = gql(PROCESS_STATES_LOADING_MUTATION) params = {"name": "{}%".format(module), "loading": status} client.execute(query, variable_values=params) except Exception: log.exception("exception")
async def test_async_client_sync_transport(event_loop, fetch_schema_from_transport): url = "http://countries.trevorblades.com/graphql" # Get sync transport sample_transport = RequestsHTTPTransport(url=url, use_json=True) # Impossible to use a sync transport asynchronously with pytest.raises(AssertionError): async with Client( transport=sample_transport, fetch_schema_from_transport=fetch_schema_from_transport, ): pass sample_transport.close()
def get_data(): _transport = RequestsHTTPTransport( url='http://localhost:5000/graphql', use_json=True, ) client = Client( transport=_transport, fetch_schema_from_transport=True, ) query = gql(""" query{ findLocationData(location: "Juja"){ uuid location region localtime tempC windKph windDegree windDir pressureMb precipMm humidity cloud } } """) return client.execute(query)
def _get_rbc_eth_ratio(token_address) -> float: """ Parse exchange rate rbc to eth from UniSwap. Return exchange rate: float. """ transport = RequestsHTTPTransport(url=UNISWAP_API_URL) client = Client(transport=transport, fetch_schema_from_transport=True) query = gql(""" { token(id: "%s"){ name symbol decimals derivedETH tradeVolumeUSD totalLiquidity } } """ % token_address.lower()) while 1: # Execute the query on the transport result = client.execute(query) if result: logging.info('UNISWAP GQL response: {}'.format( float(result.get("token").get("derivedETH")))) break return float(result.get("token").get("derivedETH"))
def test_max_characters(): transport = RequestsHTTPTransport( url=urljoin(base, "gql"), verify=False, retries=3, ) client = Client( transport=transport, fetch_schema_from_transport=True, ) long_str = "then the more there are the better in order that they neutralize each other. When in the later part of the book he comes to consider government... these three should form a crescendo but usually perform a diminuendo." q = query_str.replace("How do you do?", long_str) with pytest.raises(Exception) as e: _ = client.execute(gql(q)) assert str(e.value) == str({ "message": "1 validation error for TranslationRequest\nsource_text\n ensure this value has at most 200 characters (type=value_error.any_str.max_length; limit_value=200)", "locations": [{ "line": 2, "column": 3 }], "path": ["translation"], })
def __init__(self, url): self.url = url self.client = gql.Client( transport=RequestsHTTPTransport(url=add_url_path(url, 'graphql'), ), fetch_schema_from_transport=True, )
def test_graphql_works(): transport = RequestsHTTPTransport( url=urljoin(base, "gql"), verify=False, retries=3, ) client = Client( transport=transport, fetch_schema_from_transport=True, ) result = client.execute(query) assert result == { "translation": { "translatedText": "¿Cómo estás?", "fromLanguage": "en", "alignment": [{ "src": { "start": "0", "end": "13", "text": "How do you do?" }, "dest": { "start": "0", "end": "11", "text": "¿Cómo estás?" }, }], } }
def play(self, agent: Agent, game_id, player_id, player_token): http_transport = RequestsHTTPTransport( url=self.url, headers={'Authorization': player_token}, verify=False, retries=3) with Client(transport=http_transport, fetch_schema_from_transport=True) as session: winner = None result = session.execute(gql(START_GAME(game_id))) result = result['startGame'] state = result['state'] while True: result = session.execute( gql( DO_ACTION( game_id, agent.compute_action( 0 if result['playerOneId'] == player_id else 1, state)))) result = result['doAction'] state = result['state'] if result['status'] == GameStatus.ENDED: winner = None if result['winner'] is None else 0 if result[ 'winner']['id'] == result['playerOneId'] else 1 break if result['status'] == GameStatus.CLOSED: break agent.on_game_ended(player_id, state, winner)
def fetch_from_caida(): # we don't really care about traffic security here urllib3.disable_warnings() caida_transport = RequestsHTTPTransport( url="https://api.asrank.caida.org/v2/graphql", headers={"Content-type": "application/json"}, use_json=True, verify=False, ) client = gql.Client(retries=3, transport=caida_transport) offset = 0 has_next_page = True while has_next_page: response = client.execute(QUERY, { "first": BATCH_SIZE, "offset": offset }) has_next_page = response["asns"]["pageInfo"]["hasNextPage"] total_count = response["asns"]["totalCount"] offset += BATCH_SIZE for edge in response["asns"]["edges"]: node = edge["node"] asn, rank = node["asn"], node["rank"] yield int(asn), rank
def client_session(self): transport = RequestsHTTPTransport( url=GH_GQL_URL, headers={"Authorization": f"bearer {GH_TOKEN}"}) client = gql_client(transport=transport, fetch_schema_from_transport=True) with client as session: yield session
def __init__(self): self._config = Config() self._raw = None self._subpath_keys = None self._sublist_keys = None self._id_key = None self._translated = None self._arguments = utils.load_yaml((utils.build_yaml_path("arguments"))) self._fields = utils.load_yaml((utils.build_yaml_path("fields"))) ua = UserAgent() headers = { "User-Agent": ua.random, "Content-Type": "application/json", "Accept": "application/json, text/plain, */*", "Accept-Encoding": "gzip, deflate, br", "Accept-Language": "en-GB,en-US;q=0.9,en;q=0.8", "Connection": "keep-alive", "Host": "www.sportsbookreview.com", "Referer": "https://www.sportsbookreview.com/betting-odds/", } transport = RequestsHTTPTransport( url="https://www.sportsbookreview.com/ms-odds-v2/odds-v2-service", headers=headers, ) self.client = Client(transport=transport, fetch_schema_from_transport=False)
def _get_client() -> Client: if not (GITHUB_API_TOKEN and GITHUB_GRAPHQL_ENDPOINT): raise GithubGraphqlApiNotProperlyConfiguredException("Token and endpoint properties are required") # TODO I know it will create the same stuff all the time. Working in progress :) headers = {"Authorization": f"bearer {GITHUB_API_TOKEN}"} _transport = RequestsHTTPTransport(url=GITHUB_GRAPHQL_ENDPOINT, use_json=True, timeout=(5, 25), headers=headers) return Client(retries=3, transport=_transport, fetch_schema_from_transport=True)
def test_execute_result_error(): expected_retries = 3 client = Client( retries=expected_retries, transport=RequestsHTTPTransport( url="https://countries.trevorblades.com/", use_json=True, headers={"Content-type": "application/json"}, ), ) failing_query = gql(""" query getContinents { continents { code name id } } """) with pytest.raises(Exception) as exc_info: client.execute(failing_query) client.close() assert 'Cannot query field "id" on type "Continent".' in str( exc_info.value)
def query(name, **kwargs): url = "https://api.github.com/graphql" api_token = config.get_value("token") transport = RequestsHTTPTransport( url=url, use_json=True, headers={ "Authorization": "Bearer %s" % api_token, "Accept": "application/vnd.github.vixen-preview+json", }, ) log.debug( f"Calling query {name}.graphql with token starting {api_token[0:4]}") client = Client(transport=transport, fetch_schema_from_transport=False) queries = {} for filename in os.listdir("query"): with open(f"query/{filename}") as query_file: queries[filename.split(".")[0]] = query_file.read() query_template = Template(queries[name]) full_query = query_template.render(**kwargs) query = gql(full_query) return Dict(client.execute(query))
def test_retries_on_transport(execute_mock): """Testing retries on the transport level This forces us to override low-level APIs because the retry mechanism on the urllib3 (which uses requests) is pretty low-level itself. """ expected_retries = 3 execute_mock.side_effect = NewConnectionError("Should be HTTPConnection", "Fake connection error") transport = RequestsHTTPTransport( url="http://localhost:9999", retries=expected_retries, ) client = Client(transport=transport) query = gql(""" { myFavoriteFilm: film(id:"RmlsbToz") { id title episodeId } } """) with client: # We're using the client as context manager with pytest.raises(Exception): client.execute(query) # This might look strange compared to the previous test, but making 3 retries # means you're actually doing 4 calls. assert execute_mock.call_count == expected_retries + 1
def get_client(url, **kwargs): """ Setup the gql transport settings for hitting the FlyBase GraphQL API endpoint and return the client. :param url: - The URL for the GraphQL endpoint. :param kwargs: - Any additional keyword params to pass to the RequestsHTTPTransport class. :return: The gql.Client class object. """ flybase_transport = RequestsHTTPTransport( url=url, use_json=True, headers={ "Content-type": "application/json", }, verify=False, retries=3, **kwargs ) # Init and return GraphQL client. return Client( transport=flybase_transport, fetch_schema_from_transport=True, )
def test_execute_result_error(): expected_retries = 3 client = Client(retries=expected_retries, transport=RequestsHTTPTransport( url='https://countries.trevorblades.com/', use_json=True, headers={ "Content-type": "application/json", })) 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)
def get_graphql_client(login_response, session_cookies, graphql_token): """Create a client for GraphQL queries. Args: login_response (requests.Response): The HTTP response from the login page (required to retrieve the session cookies) session_cookies (requests.CookieJar): Session cookies, initialised at login graphql_token (int): The "UniqeID" value retrieve from the login page. Used by the "Authorization" header during GraphQL queries. """ # We transform the CookieJar object into a cookies header string # The current RequestsHTTPTransport constructor does not support # a cookies paramater, so we create a cookie header string instead. cookie_header = requests.cookies.get_cookie_header(session_cookies, login_response) headers = { 'Host': 'www.britishgas.co.uk', 'Accept': 'application/json, text/plain, */*', 'Cookie': cookie_header, 'Authorization': graphql_token, } return Client(transport=RequestsHTTPTransport(url=MYENERGY_GRAPHQL_URL, headers=headers, timeout=TIMEOUT_S), fetch_schema_from_transport=True)
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