DirtyJSON Python Decoder

1.0.8 · active · verified Thu Apr 09

dirtyjson is a Python JSON decoder (version 1.0.8, last updated Nov 2022) designed to extract data from malformed or 'dirty' JSON, often found embedded in JavaScript files. It tolerates common non-standard JSON elements like single quotes, comments (line and block), dangling commas, unquoted keys, and hexadecimal/octal numbers. It focuses solely on decoding and provides line/column number contexts for parsed elements. While its release cadence is infrequent, it remains active for specialized parsing needs.

Warnings

gotcha dirtyjson is a decoder only; it does not provide encoding capabilities (dump/dumps). For writing JSON, use Python's standard `json` library or `simplejson`.
Fix: Use `json.dumps()` or `json.dump()` for serialization.
gotcha Due to its flexibility in parsing malformed JSON, `dirtyjson` may not always produce the exact data structure or values that a user 'expects' from highly ambiguous input. Its primary goal is to extract data, not to strictly validate.
Fix: Only use `dirtyjson` when strictly necessary for malformed input. Validate the output carefully if the input quality is highly variable or unpredictable.
gotcha Unlike the standard JSON specification, `dirtyjson` handles `NaN`, `Infinity`, `-Infinity`, and hexadecimal/octal integers (`0x...`, `0o...`) as valid numbers. Additionally, it uses `AttributedDict` and `AttributedList` subclasses (which are `dict`/`list` compatible) that store line/column number metadata, differing from standard Python types.
Fix: Be aware of these non-standard interpretations and types when integrating with systems that expect strict JSON adherence or standard Python `dict`/`list` types without additional attributes.
gotcha Parsing 'dirty' or malformed JSON is inherently more complex and potentially less performant than parsing strict JSON. While `dirtyjson` is based on `simplejson`'s loader, it may not be suitable for high-performance or extremely high-reliability parsing environments compared to strict JSON parsers.
Fix: Benchmark performance if critical, and consider strict JSON parsing for inputs that are expected to be well-formed.

Install

pip install dirtyjson Install dirtyjson

Imports

loads
```
import dirtyjson
dirtyjson.loads(json_string)
```
Standard json module cannot parse dirty JSON.

load

import dirtyjson
with open('file.js') as f:
    data = dirtyjson.load(f)

Standard json module cannot parse dirty JSON from files.

Quickstart

Demonstrates parsing a malformed JSON string with unquoted keys, single quotes, comments, and a dangling comma. It also shows how to access the positional attributes stored by dirtyjson and use the resulting AttributedDict as a standard dictionary.

import dirtyjson

dirty_json_string = """
{
    name: 'John Doe', // Unquoted key, single quotes, comment
    age: 30,
    email: "john@example.com", /* Block comment */
    'is_active': true,
    data: [
        1,
        2, // Dangling comma
    ]
}
"""

try:
    data = dirtyjson.loads(dirty_json_string)
    print("Parsed data:", data)
    
    # Accessing position attributes
    name_pos = data.attributes('name')
    print(f"'name' key starts at line {name_pos.key.line}, column {name_pos.key.column}")

    # Using standard dict/list operations
    print("Name:", data['name'])
    print("First data element:", data['data'][0])

except dirtyjson.Error as e:
    print(f"Error parsing dirty JSON: {e}")

view raw JSON →