Home > Article > Backend Development > Steps to use Python to manipulate Ethereum Graph data
Before we get started, let’s look at some definitions.
The Graph project uses GraphQL, a syntax that describes how to interrogate data. This syntax is not tied to a specific type of database or storage engine, but is supported by your existing code and data.
Let’s start by looking at a very simple GraphQL query structure and the results we get when we run it. Once the GraphQL service is running, it can receive GraphQL queries for execution. The service checks the query statement to ensure that it only associates defined types and fields, and then runs the function to produce results.
As an example, look at the following query structure:
The above GraphQL query can produce the following results:
You can see that the structure of the query is the same as the result. This is crucial for GraphQL because the server knows exactly what fields the client requested.
We can use GraphQL to do the following:
You can visit the GraphQL official website to learn more about how to write complex GraphQL queries.
//m.sbmmt.com/link/b950ea26ca12daae142bd74dba4427c8
To better understand The Graph What the project is and how it works, visit thegraph.com/docs. It explains how to deploy a subgraph and how to query the subgraph's data. A subgraph defines what data TheGraph will index from Ethereum and how it will be stored. Once the subgraph is deployed, it can be queried using GraphQL syntax.
In this tutorial, we will focus on querying data from the subgraph.
1. Visit The Graph Explorer (https://thegraph.com/explorer/) to view all managed subgraphs that exist on the Ethereum blockchain. Data can be queried from each of these hosted services (subgraphs).
2. Select a subgraphs page and pay attention to the http query address and Playground of the page.
3. You need the http query address in your Python code, which is the endpoint that contains the blockchain data. This service will execute your GraphQL queries.
4. Make sure you experiment on the Playground. This section of the website will allow you to build and test your GraphQL queries for the Ethereum blockchain.
The next step is based on some queries we built in The Graph’s Playground, which can be used in our Python It is used in the code to request different data from the Ethereum blockchain.
The Python example code below contains a generic function for making a post request to a subgraph. In order to use a different subgraph, you need to change the url endpoint and GraphQL syntax. I've included a print statement at the end of the program (easier to read), so the results from the Ethereum blockchain will print out in your console.
Example 1: Query Aave on the Ethereum blockchain using GraphQL in Python to get a list of the last 10 flash loans by timestamp
import requests
# pretty print is used to print the output in the console in an easy to read format
from pprint import pprint
# function to use requests.post to make an API call to the subgraph url
def run_query(q):
# endpoint where you are making the request
request = requests.post('https://api.thegraph.com/subgraphs/name/aave/protocol'
'',
json={'query': query})
if request.status_code == 200:
return request.json()
else:
raise Exception('Query failed. return code is {}.{}'.format(request.status_code, query))
# The Graph query - Query aave for a list of the last 10 flash loans by time stamp
query = """
{
flashLoans (first: 10, orderBy: timestamp, orderDirection: desc,){
id
reserve {
name
symbol
}
amount
timestamp
}
}
"""
result = run_query(query)
# print the results
print('Print Result - {}'.format(result))
print('#############')
# pretty print the results to make it easier to read
pprint(result)
Example 2: Using Python GraphQL in Query Uniswap on the Ethereum blockchain to get a list of the top 10 pairs
The query below is a ranking list of Uniswap detailing the top ETH flows in descending order by ETH deposit amount Sex supplier. This can help you better analyze user behavior, such as tracking popular players in the market and observing the relationship between ETH’s liquidity providers and other tokens. Other user fields that can be queried include their address, historical assets bought and sold, and the total fees paid by that user.
import requests
# pretty print is used to print the output in the console in an easy to read format
from pprint import pprint
# function to use requests.post to make an API call to the subgraph url
def run_query(q):
# endpoint where you are making the request
request = requests.post('https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v2'
'',
json={'query': query})
if request.status_code == 200:
return request.json()
else:
raise Exception('Query failed. return code is {}.{}'.format(request.status_code, query))
# The Graph query - Query Uniswap for a list of the top 10 pairs where the reserve is > 1000000 USD and the volume is >50000 USD
query = """
{
pairs(first: 10, where: {reserveUSD_gt: "1000000", volumeUSD_gt: "50000"}, orderBy: reserveUSD, orderDirection: desc) {
id
token0 {
id
symbol
}
token1 {
id
symbol
}
reserveUSD
volumeUSD
}
}
"""
result = run_query(query)
# print the results
print('Print Result - {}'.format(result))
print('#############')
# pretty print the results
pprint(result)
Using The Graph to query Ethereum data in Python is very powerful. There is a lot of data that can be queried for reporting and analysis.
This code is for learning and entertainment purposes only. This code has not been audited, use it at your own risk, the contract is experimental and may contain bugs.
The above is the detailed content of Steps to use Python to manipulate Ethereum Graph data. For more information, please follow other related articles on the PHP Chinese website!