Let's Build a Mini-Redis! Your Own Key-Value Store 🚀

Step 2: Talking to Our Store - SET and GET Commands 🗣️

Our dictionary `my_store` is great, but how do we actually *use* it like a real key-value store? We need a way to tell it what to do! This is where commands come in. We'll start with the two most fundamental ones:

• SET key value: Stores a given `value` associated with a `key`.
• GET key: Retrieves the `value` associated with a `key`.

Hearing What the User Says 👂: Input Parsing

To make our store interactive, we need to get input from the user. Python's built-in `input()` function is perfect for this. Once we have the user's typed command (like "SET name Jules"), we need to break it apart into meaningful pieces – the command itself, the key, and potentially the value. The `split()` string method is our friend here.

# Example of getting and splitting input
user_command = input("> ")  # Prompts the user with "> "
parts = user_command.split() # Splits the string by spaces

command = parts[0] # The first part is the command
# parts[1:] will be the arguments (key, value)
print(f"Command: {command}")
print(f"Arguments: {parts[1:]}")

# Try typing: SET fruit Apple
# Output:
# Command: SET
# Arguments: ['fruit', 'Apple']
                

Remember, `split()` without arguments splits by any whitespace and handles multiple spaces gracefully. If you need to set a value that contains spaces, like "New York City", you'll need a slightly more advanced way to handle `parts`, often by joining the later parts: `value = " ".join(parts[2:])`. For now, we'll assume values don't have spaces.

Implementing SET ✅

The SET command needs a key and a value. It stores this pair in our `my_store` dictionary. A simple way to confirm the operation is to print "OK".

my_store = {} # Our global store

def handle_set(key, value):
    my_store[key] = value
    return "OK"

# Example usage:
# result = handle_set("language", "Python")
# print(result) # Output: OK
# print(my_store) # Output: {'language': 'Python'}
                

Implementing GET 🔍

The GET command needs a key and should return its corresponding value. What if the key isn't in our store? Real Redis returns "(nil)". We can do something similar, like returning `None` or a specific string like "(nil)" or "(key not found)". Python's dictionary `get()` method is great here, as it can return a default value if the key is missing, avoiding a `KeyError`.

# my_store should be defined as in the SET example

def handle_get(key):
    # Using dict.get(key, default_value) is safer than my_store[key]
    value = my_store.get(key) 
    if value is None:
        return "(nil)" # Or return None and let the REPL handle printing
    return f'"{value}"' # Often, string values are returned in quotes

# Example usage (assuming 'language': 'Python' is in my_store):
# print(handle_get("language")) # Output: "Python"
# print(handle_get("city"))     # Output: (nil)
                

A Simple REPL (Read-Eval-Print Loop) 🔄

Now let's put it all together in a loop! A REPL reads user input, evaluates it (runs our SET or GET logic), prints the result, and then loops back for more. We'll keep it simple for now.

# Make sure my_store, handle_set, and handle_get are defined as above

print("Simple Key-Value Store REPL. Type 'QUIT' to exit.")
while True:
    user_input = input("kv_store> ").strip() # Get input and remove extra whitespace
    
    if not user_input: # If user just presses Enter
        continue

    parts = user_input.split()
    command = parts[0].upper() # Convert command to uppercase for case-insensitivity

    if command == "QUIT":
        print("Exiting store. Bye! 👋")
        break
    elif command == "SET":
        if len(parts) >= 3:
            key = parts[1]
            value = " ".join(parts[2:]) # Join all parts for the value
            print(handle_set(key, value))
        else:
            print("Error: SET command needs a key and a value. Usage: SET  ")
    elif command == "GET":
        if len(parts) >= 2:
            key = parts[1]
            print(handle_get(key))
        else:
            print("Error: GET command needs a key. Usage: GET ")
    else:
        print(f"Error: Unknown command '{command}'. Available commands: SET, GET, QUIT.")

# You can try this full REPL code in the 'Try it Yourself Lab' below!
# Example interaction:
# kv_store> SET greeting Hello World
# OK
# kv_store> GET greeting
# "Hello World"
# kv_store> GET non_existent_key
# (nil)
# kv_store> QUIT
# Exiting store. Bye! 👋
                

This REPL is basic. It converts commands to uppercase (so "set" and "SET" both work) and handles a simple "QUIT" command. It also has very basic error checking for the number of arguments for SET and GET. We'll improve error handling in a later section!

🚀 You can copy the full REPL code (including the `my_store` dictionary and the `handle_set` / `handle_get` functions) into the "Try it Yourself Lab" below to run your own interactive key-value store!

Test Your Knowledge! 🧠 (Section 2)

Step 3: Don't Forget! - Saving Our Data to a File 💾

Our key-value store is getting pretty cool! But there's a big catch: all our data is stored in memory. If you close the program and run it again, poof! 💨 Everything's gone. To make our store truly useful, we need persistence – the ability to save data to a file and load it back up.

The Basics of File I/O (Input/Output) 📄

Python makes working with files straightforward. The core function is `open()`, which takes a filename and a mode (like 'r' for read, 'w' for write, 'a' for append).

• 'r': Read mode. Opens the file for reading. Error if the file doesn't exist.
• 'w': Write mode. Opens the file for writing. Creates the file if it doesn't exist, or overwrites it if it does! Be careful!
• 'a': Append mode. Opens for writing, but appends to the end of the file instead of overwriting.

After opening a file, you can use methods like `read()` or `write()`. Crucially, you must always `close()` the file to ensure data is properly saved and resources are freed.

A much safer way to work with files is using the with open(...) as f: statement. This automatically closes the file for you, even if errors occur.

# Writing to a file
with open("my_data.txt", "w") as f:
    f.write("Hello, file world!\n")
    f.write("This is a new line.")

# Reading from a file
with open("my_data.txt", "r") as f:
    content = f.read()
    print(content)
# Output:
# Hello, file world!
# This is a new line.
                

Turning Dictionaries into File-Friendly Data: JSON 💡

You can't just write a Python dictionary directly to a file using `f.write(my_store)`. It won't work as you expect. We need to serialize our dictionary – convert it into a string format that can be easily written to a file and then read back (deserialized) into a dictionary.

The json (JavaScript Object Notation) module is perfect for this. It's a standard text format that's human-readable and widely used.

• json.dump(data, file_object): Writes your Python dictionary `data` to an open `file_object` in JSON format.
• json.load(file_object): Reads JSON data from an open `file_object` and converts it back into a Python dictionary.

import json # Don't forget to import!

my_contacts = {"name": "Jules", "city": "Paris"}
filename = "contacts.json"

# Saving the dictionary to a file
with open(filename, "w") as f:
    json.dump(my_contacts, f, indent=4) # indent=4 makes it human-readable

# Loading the dictionary from the file
with open(filename, "r") as f:
    loaded_contacts = json.load(f)
    print(loaded_contacts) # Output: {'name': 'Jules', 'city': 'Paris'}
    print(loaded_contacts == my_contacts) # Output: True
                

Integrating Persistence into Our Store 🔄

Let's make our key-value store use a file (e.g., `my_kv_store.json`) for persistence.

1. Define a filename: Choose a name for your data file.
2. Load data on startup: When the store starts, try to load data from this file. If the file doesn't exist (maybe it's the first run), start with an empty dictionary.
3. Save data on changes: After every successful `SET` (and later `DEL`) command, save the entire `my_store` dictionary to the file.

Note: Saving the entire dictionary after every write is simple but not very efficient for large stores. Real databases use more complex techniques, but this is a great starting point!

import json
import os # Needed for checking if file exists, though try-except is often better for loading

STORE_FILENAME = "my_kv_store.json"
my_store = {} # Our global store

def load_store_from_file():
    global my_store # We are modifying the global variable
    try:
        with open(STORE_FILENAME, "r") as f:
            my_store = json.load(f)
            print(f"Store loaded from {STORE_FILENAME}")
    except FileNotFoundError:
        my_store = {} # Start with an empty store if file not found
        print(f"{STORE_FILENAME} not found. Starting with an empty store.")
    except json.JSONDecodeError:
        my_store = {} # If file is corrupted, start fresh (or handle error differently)
        print(f"Error decoding JSON from {STORE_FILENAME}. Starting fresh.")


def save_store_to_file():
    with open(STORE_FILENAME, "w") as f:
        json.dump(my_store, f, indent=4)
    # print(f"Store saved to {STORE_FILENAME}") # Optional: for debugging

# --- Update handle_set ---
def handle_set(key, value):
    my_store[key] = value
    save_store_to_file() # Save after every successful set
    return "OK"

# --- Update handle_get (no change needed for saving, only reading) ---
def handle_get(key):
    value = my_store.get(key) 
    if value is None:
        return "(nil)"
    return f'"{value}"'

# --- Main REPL (Modified) ---
# load_store_from_file() # Load the store when the program starts!

# print("Simple Key-Value Store REPL (with Persistence!). Type 'QUIT' to exit.")
# while True:
#     user_input = input("kv_store_persist> ").strip()
    
#     if not user_input:
#         continue

#     parts = user_input.split()
#     command = parts[0].upper()

#     if command == "QUIT":
#         print("Exiting store. Bye! 👋")
#         break
#     elif command == "SET":
#         if len(parts) >= 3:
#             key = parts[1]
#             # For values with spaces:
#             value = " ".join(parts[2:]) 
#             print(handle_set(key, value))
#         else:
#             print("Error: SET command needs a key and a value.")
#     elif command == "GET":
#         if len(parts) >= 2:
#             key = parts[1]
#             print(handle_get(key))
#         else:
#             print("Error: GET command needs a key.")
#     else:
#         print(f"Error: Unknown command '{command}'.")

# Try adding the load_store_from_file() call at the beginning of your REPL,
# and the save_store_to_file() call within handle_set (and later handle_del).
# You'll see your data persist across sessions!
                

Now, if you run your REPL, set some keys, quit, and run it again, your data should still be there! Magic! ✨ (Well, not magic, just file I/O and JSON).

Test Your Knowledge! 🧠 (Section 3)

Step 4: Cleaning Up - The DEL Command and Error Smashing 💥

Our store can remember things and even save them to a file! But what if we want to remove something? That's where the DEL key command comes in. Plus, our current REPL is a bit too trusting; if we type commands incorrectly, it might crash or do weird things. Let's add some basic error handling!

Implementing DEL 🗑️

The DEL command needs a key to specify which item to remove. We'll use Python's `del` keyword to remove the key-value pair from our `my_store` dictionary.

What should DEL return? Redis returns the number of keys that were removed. For a simple `DEL key` (not `DEL key1 key2 ...`), this will be 1 if the key existed and was deleted, or 0 if the key didn't exist. And yes, if persistence is active, we need to save the store after a successful deletion!

# Assume my_store, STORE_FILENAME, and save_store_to_file() are defined

def handle_del(key):
    global my_store
    if key in my_store:
        del my_store[key]
        save_store_to_file() # Save changes if persistence is on
        return "1" # Key was found and deleted
    else:
        return "0" # Key was not found

# Example usage:
# my_store = {"name": "Jules", "city": "Lyon"} # Reset for example
# save_store_to_file() # Save initial state
# print(handle_del("city"))  # Output: 1
# print(my_store)            # Output: {'name': 'Jules'}
# print(handle_del("country")) # Output: 0
                

Basic Error Smashing (Handling) 🔥

Our current REPL is fragile. If you type `SET` without a key and value, or `GET` without a key, it will likely crash with an `IndexError` because it tries to access `parts[1]` or `parts[2]` that don't exist.

We can make it more robust by checking the number of `parts` (the length of the list after `split()`) before trying to access elements by their index.

# --- REPL with improved error handling (partial example) ---
# Assume my_store, handle_set, handle_get, handle_del, load_store_from_file are defined.
# load_store_from_file() # Load at start

# print("Improved Key-Value Store REPL. Type 'QUIT' to exit.")
# while True:
#     user_input = input("kv_store_robust> ").strip()
#     if not user_input:
#         continue
#     parts = user_input.split()
#     command = parts[0].upper()

#     if command == "QUIT":
#         print("Exiting. Bye! 👋")
#         break
#     elif command == "SET":
#         if len(parts) >= 3: # Need at least 'SET', 'key', 'value'
#             key = parts[1]
#             value = " ".join(parts[2:]) # Handle multi-word values
#             print(handle_set(key, value))
#         else:
#             print("❗ Error: SET requires a key and a value. Usage: SET  ")
#     elif command == "GET":
#         if len(parts) >= 2: # Need at least 'GET', 'key'
#             key = parts[1]
#             print(handle_get(key))
#         else:
#             print("❗ Error: GET requires a key. Usage: GET ")
#     elif command == "DEL":
#         if len(parts) >= 2: # Need at least 'DEL', 'key'
#             key = parts[1]
#             print(handle_del(key))
#         else:
#             print("❗ Error: DEL requires a key. Usage: DEL ")
#     else:
#         print(f"❗ Error: Unknown command '{command}'. Available: SET, GET, DEL, QUIT.")

# Example Interactions:
# kv_store_robust> SET name Pixel
# OK
# kv_store_robust> GET name
# "Pixel"
# kv_store_robust> DEL name
# 1
# kv_store_robust> GET name
# (nil)
# kv_store_robust> SET
# ❗ Error: SET requires a key and a value. Usage: SET  
# kv_store_robust> GET
# ❗ Error: GET requires a key. Usage: GET 
# kv_store_robust> DEL
# ❗ Error: DEL requires a key. Usage: DEL 
                

This is just the tip of the iceberg for error handling! Proper error handling can involve more specific checks (e.g., are keys/values valid?), custom error types, and more user-friendly messages. But even these simple `len(parts)` checks make our store much more usable.

🚀 Feel free to integrate `handle_del` and the improved error checks into the full REPL code in the "Try it Yourself Lab" below!

Test Your Knowledge! 🧠 (Section 4)