https://github.com/jeff-hykin/json_fix

💾 📦 ✅ A fix for the 1000 upvotes python-json question
https://github.com/jeff-hykin/json_fix

json python

Last synced: 8 days ago
JSON representation

💾 📦 ✅ A fix for the 1000 upvotes python-json question

• Host: GitHub
• URL: https://github.com/jeff-hykin/json_fix
• Owner: jeff-hykin
• Created: 2021-08-25T14:22:58.000Z (over 3 years ago)
• Default Branch: master
• Last Pushed: 2024-12-18T21:02:34.000Z (about 2 months ago)
• Last Synced: 2025-02-06T09:18:44.609Z (9 days ago)
• Topics: json, python
• Language: Shell
• Homepage:
• Size: 1.39 MB
• Stars: 26
• Watchers: 3
• Forks: 1
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# What is this?

A pip module that lets you define a `__json__` method, that works like `toJSON` from JavaScript.


(e.g. it magically gets called whenever someone does `json.dumps(your_object)`)

From a technical perspective, this module is a safe, backwards-compatible, reversable patch to the built-in python `json` object that allows classes to specify how they should be serialized.

# Why?

Because sometimes external code uses something like

```python

import json

json.dumps(list_containing_your_object)

```

And it simply throws an error no matter how you customize your object

# How do I use this for my class?

`pip install json-fix`

```python

import json_fix # import this before the JSON.dumps gets called

# same file, or different file

class YOUR_CLASS:

    def __json__(self):

        # YOUR CUSTOM CODE HERE

        #    you probably just want to do:

        #        return self.__dict__

        return "a built-in object that is natually json-able"

```

# How do I change how someone elses class is jsonified?

There's 2 ways; the aggressive `override_table` or the more collaboration-friendly `fallback_table`. Some really powerful stuff can be done safely with the fallback table.

## Override Table

If a pip module defines a class, you can control how it is json-dumped, even if they defined a `.__json__()` method, by using `json.override_table`.

- Note! The "when" (in when-a-rule-is-added) can be very important. Whatever rule was most-recently added will have the highest priority. So, even if a pip module uses the override table, you can override their override by doing `import that_module` and THEN adding your rule to the override table.

- Note 2! The override table is capable of changing how built-in types are dumped, be careful! 

```python

import json_fix # import this before the JSON.dumps gets called

import json

import pandas as pd

SomeClassYouDidntDefine = pd.DataFrame

# create a boolean function for identifying the class

class_checker = lambda obj: isinstance(obj, SomeClassYouDidntDefine)

# then assign it to a function that does the converting

json.override_table[class_checker] = lambda obj_of_that_class: json.loads(obj_of_that_class.to_json())

json.dumps([ 1, 2, SomeClassYouDidntDefine() ], indent=2) # dumps as expected

```

## Fallback Table

Let's say we want all python classes to be jsonable by default, well we can easily do that with the fallback table. The logic is `if notthing in override table, and no .__json__ method, then check the fallback table`. 

```python

import json_fix # import this before the JSON.dumps gets called

import json

# a checker for custom objects

checker = lambda obj: hasattr(obj, "__dict__")

# use the __dict__ when they don't specify a __json__ method 

json.fallback_table[checker] = lambda obj_with_dict: obj_with_dict.__dict__

class SomeClass:

    def __init__(self):

        self.thing = 10

json.dumps([ 1, 2, SomeClass() ], indent=2) # dumps as expected

```

Like the override table, the most recently-added checker will have the highest priority.