JSON Extractor

The JSONExtractor is a utility component within the underdogcowboy library that simplifies the process of extracting and validating JSON data embedded within text.

Features

1. Extraction: The JSONExtractor can identify and extract JSON data from a given text.

2. Parsing: The extracted JSON data is parsed and returned as a Python dictionary.

3. Inspection: The component provides detailed inspection data about the extracted JSON, including the number of keys, the presence of expected keys, and whether the extracted keys match the expected keys.

4. Validation: The JSONExtractor can validate the extracted JSON data against a set of expected keys and inspection criteria, making it easy to ensure the integrity of the data.

Usage

Here's a simple example of how to use the JSONExtractor:

from underdogcowboy import JSONExtractor

# Create a sample text with JSON embedded
sample_text = """
This is some random text. Here's our JSON data:
{"name": "John Doe", "age": 30, "city": "New York", "is_student": false}
And here's some more text after the JSON.
"""

# Define the expected keys
expected_keys = ["name", "age", "city", "is_student"]

# Create an instance of JSONExtractor
extractor = JSONExtractor(sample_text, expected_keys)

# Extract and parse the JSON
json_data, inspection_data = extractor.extract_and_parse_json()

# Print the results
print("Extracted JSON data:")
print(json_data)
print("\nInspection data:")
print(inspection_data)

# Define expected inspection data
expected_inspection_data = {
    'number_of_keys': 4,
    'keys': ["name", "age", "city", "is_student"],
    'values_presence': {"name": True, "age": True, "city": True, "is_student": True},
    'keys_match': True
}

# Check the inspection data against the expected data
is_correct, deviations = extractor.check_inspection_data(expected_inspection_data)

print("\nIs the extracted data correct?", is_correct)
if not is_correct:
    print("Deviations found:")
    print(deviations)
else:
    print("No deviations found.")

Use Cases

The JSONExtractor can be useful in a variety of scenarios, such as:

1. Data Extraction: Extracting JSON data from text-based sources, such as log files, API responses, or user-generated content.

2. Data Validation: Verifying the structure and contents of JSON data to ensure it meets specific requirements.

3. Data Preprocessing: Incorporating the JSONExtractor into a larger data processing pipeline to automatically extract and validate JSON data.

4. Extracting JSON from LLM Responses: The JSONExtractor can be particularly useful for processing responses from Large Language Models (LLMs) that may contain embedded JSON data.

Here's an example of how you can use the JSONExtractor to extract and validate JSON data from an LLM response:

from underdogcowboy import JSONExtractor

def process_llm_response(llm_response):
    """
    Extracts and validates JSON data from an LLM response.
    
    Args:
        llm_response (str): The response from the Large Language Model.
    
    Returns:
        dict: The extracted and validated JSON data, or None if the extraction fails.
    """
    # Define the expected keys
    expected_keys = ["name", "age", "city", "is_student"]
    
    # Create an instance of JSONExtractor
    extractor = JSONExtractor(llm_response, expected_keys)
    
    # Extract and parse the JSON
    json_data, inspection_data = extractor.extract_and_parse_json()
    
    # Define expected inspection data
    expected_inspection_data = {
        'number_of_keys': 4,
        'keys': expected_keys,
        'values_presence': {key: True for key in expected_keys},
        'keys_match': True
    }
    
    # Check the inspection data against the expected data
    is_correct, deviations = extractor.check_inspection_data(expected_inspection_data)
    
    if is_correct:
        return json_data
    else:
        print("Deviations found in LLM response:")
        print(deviations)
        return None

In this example, the process_llm_response function takes an LLM response as input, uses the JSONExtractor to extract and validate the JSON data, and returns the extracted JSON data if it meets the expected criteria. If the validation fails, the function prints the deviations and returns None.

You can then incorporate this function into your LLM processing pipeline to automatically extract and validate JSON data from the model's responses. This can be particularly useful when the LLM is expected to return structured data as part of its output, and you need to ensure the integrity of that data before using it in your application.

Limitations

The JSONExtractor is designed to handle simple JSON data embedded within text. It may not be suitable for extracting and validating more complex JSON structures or dealing with advanced parsing requirements. For more advanced JSON handling, users may need to consider using dedicated JSON parsing libraries or implementing custom solutions.

The limitations of the current JSONExtractor implementation in a nutshell:

1. Limited to simple JSON structures, unable to handle complex nested objects or arrays.

2. Lacks robust error handling, returning only generic error messages.

3. Offers limited configurability, with fixed extraction and validation logic.

4. Uses inefficient brute-force approach for JSON extraction, impacting performance.

5. Does not incorporate performance optimization techniques like caching or parallel processing.