Merge pull request #181 from banker/redis-py-4

Updates Python/RedisJSON document for latest client.

Author: Simon Prickett

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

@@ -3,144 +3,125 @@ 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 features of RedisJSON, and in this tutorial, we'll see how to get started with 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
-
-Let us consider a simple JSON document structure:
-
-```
-employee
- {
-  "name": "Paul John",
-  "age": 25,
-  "location: "USA"
- }
-```
-
-Below is a python code to store the JSON document into Redis:
+Ensure that you're running RedisJSON v2.0 or greater (here indicated as `20004`).
 
-```python
-from rejson import Client, Path
+## Load the latest version of `redis-py`
 
+You'll need `redis-py` version 4.0 or later. If you're using `pipenv`, you can install the client library like so:
 
-rj = Client(host='localhost', port=6379, decode_responses=True)
+```bash
+pipenv install redis
+```
 
-employee = {
+Then you can run `pipenv graph` to make sure you're running the latest version of the client:
 
-     '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": 33,
+  "location: "Chawton"
+ }
 ```
 
-### 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 reference 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 in the key. The result is a Python dictionary representing the JSON object stored in Redis.
 
-rj = Client(host='localhost', port=6379, decode_responses=True)
+### Run the code
 
-employee = {
+If you copy the code above into a file called `main.py`, you can run the code like so:
 
-     'name': "Paul", 
-     'Age': '25', 
-     'address': {
-        'location': "USA"
-   }
-  }
-rj.jsonset('employee', Path.rootPath(), employee)
-rj.jsonget('employee', Path('.address.location'))
+```bash
+$ pipenv python run main.py
 ```
 
-In the above example, the code tries to fetch only the location under the address field.
-
-
-### 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. Then 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 specific fields from 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
 
 - [RU204: Storing, Querying and Indexing JSON at Speed](https://university.redis.com/courses/ru204/) - a course at Redis University
-- [How to cache JSON data in Redis with Python](/howtos/redisjson/using-python)
 - [Importing JSON data into Redis using NodeJS](/howtos/redisjson/using-nodejs)
-- Learn more about [RedisJSON](https://redisjson.io) in the Quickstart tutorial.
+- Learn more about [RedisJSON](https://redisjson.io) in the Quickstart tutorial