Update Python/RedisJSON tutorial

Author: Kyle Banker

docs/howtos/redisjson/using-python/index-usingpython.mdx

@@ -3,138 +3,120 @@ id: index-usingpython
 title: How to store JSON documents in Redis with Python 
 sidebar_label: RedisJSON and Python
 slug: /howtos/redisjson/using-python
-authors: [ajeet]
 ---
 
+[RedisJSON](https://oss.redis.com/redisjson/) is a source-available Redis module that lets you store, manipulate, and query JSON documents in Redis. The standard Redis Python client (v4.0 or greater) supports all of the feature of RedisJSON, and in this tutorial, we'll see how to use them.
 
-RedisJSON is a Redis module that lets you store JSON documents in Redis. It is a JSON data type for Redis that lets you to fetch or modify a specific element in the document tree, without retrieving (or internally even parsing) the document. Its Python client even lets you store python dicts and convert them to JSON automatically.
+## Getting started with RedisJSON
 
-### RedisJSON Python Client
-
-
-The 'rejson-py' is a package that allows storing, updating and querying objects as JSON documents in a Redis database that is extended with the RedisJSON module. The package extends redis-py's interface with RedisJSON's API, and performs on-the-fly serialization/deserialization of objects to/from JSON.
-
-Follow the steps below to get started with RedisJSON with Python:
-
-
-### Step 1. Run RedisJSON Docker container
+To run the examples below, you'll need to ensure that you have an instance of Redis that includes RedisJSON. If you're developing locally, you can use Docker for this:
 
 ```bash
  docker run -p 6379:6379 --name redis-redisjson redislabs/rejson:latest
 ```
 
+## Verify that the RedisJSON module is loaded
 
-### Step 2. Verify if RedisJSON module is loaded
+Connect to Redis using `redis-cli`, and run the `info modules` command:
 
 ```bash
  redis-cli
  127.0.0.1:6379> info modules
  # Modules
- module:name=ReJSON,ver=10007,api=1,filters=0,usedby=[],using=[],options=[]
+ module:name=ReJSON,ver=20004,api=1,filters=0,usedby=[],using=[],options=[]
  127.0.0.1:6379> 
 ```
 
-### Step 3. Storing the JSON document
+Ensure that you're running RedisJSON v2.0 or greater (here indicated as `20004`).
+
+## Load the latest version of `redis-py`
 
-Let us consider a simple JSON document structure:
+You'll need `redis-py` version 4.0 or later. If you're using `pipenv`, you can install the client library like so:
 
 ```
-employee
- {
-  "name": "Paul John",
-  "age": 25,
-  "location: "USA"
- }
+pipenv install redis
 ```
 
-Below is a python code to store the JSON document into Redis:
+Then you can run `pipenv graph` to make sure you're running the latest version of the client:
 
-```python
-from rejson import Client, Path
-
-
-rj = Client(host='localhost', port=6379, decode_responses=True)
-
-employee = {
-
-     'name': "Paul", 
-     'Age': '25', 
-     'Location': "USA"
-   }
-rj.jsonset('employee', Path.rootPath(), employee)
+```
+$ pipenv graph
+redis==4.0.2
 ```
 
-In the code above, we use JSON.GET to extract the JSON elements. Save the above file as "employee.py".
+## Storing JSON in Redis
 
-### Step 4. Load Redis Module
+Let's consider a simple JSON document structure representing a user:
 
-```bash
- pip  install rejson
 ```
-
-### Step 5. Execute the python script
-
-```bash
- python3 employee.py
+ {
+  "name": "Jane",
+  "age": 25,
+  "location: "USA"
+ }
 ```
 
-### Step 6. Verify the JSON document added to Redis
+Here's the Python code to store this document in Redis using RedisJSON:
 
+```python
+import redis
+from redis.commands.json.path import Path
 
-<b>Command</b>:
+client = redis.Redis(host='localhost', port=6379, db=0)
 
-```bash
- 127.0.0.1:6379> JSON.GET employee
-```
+jane = {
+     'name': "Jane", 
+     'Age': 33, 
+     'Location': "Chawton"
+   }
 
-<b>Result</b>:
+client.json().set('person:1', Path.rootPath(), jane)
 
-```
- "{\"name\":\"Paul\",\"Age\":\"25\",\"Location\":\"USA\"}"
- 127.0.0.1:6379> 
+result = client.json().get('person:1')
+print(result)
 ```
 
-### Step 7. Fetching the specific fields within JSON document
+In the code above, we first connect to Redis and store a reference to the connection in the `client` variable.
 
-It's possible to fetch specific field within JSON element. Let us modify the above code and add "address" field as shown below:
+Next, we create a Python dictionary to represent a person object.
 
-```python
- from rejson import Client, Path
+And finally, we store the object in Redis using the `json().set()` method. The first argument, `person:1` is the name of the key that will store the JSON. The second argument is a JSON path. We use `Path.rootPath()`, as this is a new object. Finally, we pass in the Python dictionary, which will be serialized to JSON.
 
+To retrieve the JSON object, we run `json().get()`, passing the key. The result is the Python dictionary we passed in.
 
-rj = Client(host='localhost', port=6379, decode_responses=True)
+### Run the code
 
-employee = {
-
-     'name': "Paul", 
-     'Age': '25', 
-     'address': {
-        'location': "USA"
-   }
-  }
-rj.jsonset('employee', Path.rootPath(), employee)
-rj.jsonget('employee', Path('.address.location'))
-```
-
-In the above example, the code tries to fetch only the location under the address field.
+If you copy the code above in a file called `main.py`, you can run the code like so:
 
+```bash
+$ pipenv python run main.py
 
-### Step 8. Verifying the results
 
+## Verify that the JSON document has been added to Redis
 
-<b>Command</b>:
+Start `redis-cli` to connect to your Redis instance. The run the following command:
 
 ```bash
- 127.0.0.1:6379> JSON.GET employee .address.location
+localhost:6379> json.get person:1
+"{\"name\":\"Jane\",\"Age\":33,\"Location\":\"Chawton\"}"
 ```
 
+## Fetching the specific fields within a JSON document
 
-<b>Results</b>:
+You can use RedisJSON to fetch specific fields from a document by specifying a path. For example, here's how to return only the `name` field:
 
+```python
+name = client.json().get('person:1', Path('.name'))
+print(name)
 ```
- "\"USA\""
-```
+This code will print the string "Jane".
+
+You can execute the same query from the command line:
 
+```bash
+localhost:6379> json.get person:1 '.name'
+"\"Jane\""
+```
 
 ### References