Say I have a class inheritance structure, and I want to generically be able to dump/load with the correct class types in the inheritance structure.

@dataclass
class A(object):
    foo: int

@dataclass
class B(A):
    bar: int

Assume that when loading, I do now know which class type it was dumped from. I would have to analyse the content to determine which class to load as, and then pass this to the cls property of jsons.load method.

Would it make sense to implement an optional flag when dumping to a dictionary that contains information of what class type it was dumped as, that can then be used for loading?

It seems like serialization using jsons.dump(obj) is at least 10 times slower than writing custom serialization method to each class. In my case, obj was a nested dataclasses and data was in the order of 100MBs.

I can pull up some numbers but I just wanted to start a discussion if this is a known issue and if so, what might cause this?

The datetime instance is wrongly serialized if initialized from utcnow(). Example:

dt_local = datetime.datetime.now()
print(dt_local)
# >>> 2019-02-16 17:48:34.714603

print(jsons.dump(dt_local))
# >>> 2019-02-16T17:48:34+01:00

dt_utc = datetime.datetime.utcnow()
print(dt_utc)
# >>> 2019-02-16 16:48:34.715108

print(jsons.dump(dt_utc))
# >>> 2019-02-16T16:48:34+01:00
# this last one is clearly wrong

This code:

import jsons
from typing import List

jsons.load(["Hello", "World"], List)

would fail with a: TypeError: 'NoneType' object is not callable.

This is because the bare List type contains an __args__[0] which is a TypeVar, which is not callable when deserializing.

This pull request fixed that by checking if the __args__[0] is actually usable and not just a bare TypeVar.

UserWarning: Failed to dump attribute "<class 'MyClassName'>" of object of type "MyType". Reason: descriptor 'mro' of 'type' object needs an argument. Ignoring the attribute.

Hi there, I'm trying to switch to this from jsonpickle and am running into a case in which the above failure happens hundreds of times on a variety of nested objects. Any idea what the issue is?

resolves #160 Other container serializers/deserializers don't seem to be affected by this bug, since they seem to already handle fork_inst correctly, though I haven't tested this.

as per https://bugs.python.org/issue34776

there can be issues when doing something like:

from __future__ import annotations
from typing import Optional, get_type_hints

@dataclass
class Foo:
   a: Optional[int]


get_type_hints(Foo.__init__)

will give

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python3.7/typing.py", line 1001, in get_type_hints
    value = _eval_type(value, globalns, localns)
  File "/usr/lib/python3.7/typing.py", line 260, in _eval_type
    return t._evaluate(globalns, localns)
  File "/usr/lib/python3.7/typing.py", line 464, in _evaluate
    eval(self.__forward_code__, globalns, localns),
  File "<string>", line 1, in <module>
NameError: name 'Optional' is not defined

Which causes such classes not to be able to read in by jsons.

A workaround is to ensure that get_type_hints has the module dict of the class available to it.

Hi there,

Loading a 1Go JSON file may take a while. Using the standard JSON API with the same JSON file may take approximatively 35 seconds.

with jsons: time~ 20min

    with open(json_path, "r") as json_file:
        content = json_file.readlines()
        json_data = jsons.loads(content[0], CustomObject)

The readlines function take 2 or 3 seconds.

with json: time~ 35s

    with open(json_path, "r") as json_file:
        content = json.load(json_file)
        json_data = CustomObject(**content)

What I'm doing wrong ?

import jsons
import numpy as np
jsons.dumps(np.array([0]))

causes the following error message to repeat:

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/usr/local/anaconda3/lib/python3.7/site-packages/jsons/_main_impl.py", line 63, in dump
    return serializer(obj, cls=cls, **kwargs_)
  File "/usr/local/anaconda3/lib/python3.7/site-packages/jsons/serializers/default_object.py", line 56, in default_object_serializer
    **kwargs_)
  File "/usr/local/anaconda3/lib/python3.7/site-packages/jsons/serializers/default_dict.py", line 25, in default_dict_serializer
    strip_nulls=strip_nulls, **kwargs)
  File "/usr/local/anaconda3/lib/python3.7/site-packages/jsons/_main_impl.py", line 65, in dump
    raise SerializationError(str(err))
jsons.exceptions.SerializationError: maximum recursion depth exceeded in comparison

Hi~, I using udatetime and jsons, the udatetime return UTC timezone is +00:00

udatetime.utcnow()
datetime.datetime(2019, 4, 12, 8, 31, 12, 471970, tzinfo=+00:00)

So, is allow to add +00:00 to _datetime_offset_str in _datetime_impl.py ?

if tzone.tzname(None) not in ('UTC', 'UTC+00:00'):

edit to

if tzone.tzname(None) not in ('UTC', 'UTC+00:00', '+00:00'):

Inherited class is lost while deserialization. In the example below, the object chmsg3 is serialized as a class ChatMessageSection with the weight attribute ('weight': 17, '-cls': 'main.ChatMessageSection'}]). But after deserialization the object becomes a ChatMessage.

import jsons
from dataclasses import dataclass
from typing import List

@dataclass
class ChatUser:
    name: str

@dataclass
class ChatMessage:
    user: ChatUser
    msg_text: str

@dataclass
class ChatMessageSection(ChatMessage):
    weight: int

@dataclass
class ChatMessages:
    msg_list: List[ChatMessage]

chmsg = ChatMessage(ChatUser("Thierry"), "Bonjour")
chmsg2 = ChatMessage(ChatUser("Casimir"), "Hello")
chmsg3 = ChatMessageSection(ChatUser("Leonard"), "Coucou", weight=17)
chat_msgs = ChatMessages([chmsg, chmsg2, chmsg3])

print(chat_msgs, end="\n\n")
dumped = jsons.dump(chat_msgs, strip_microseconds=True, verbose=jsons.Verbosity.WITH_EVERYTHING)
print(dumped, end="\n\n")
instance = jsons.load(dumped)
print(instance, end="\n\n")

Hey there,

When "deserializating" a dictionary that contains a decimal.Decimal field, to a class that accepts that field as an int or a float, JSONS is throwing an exception:

Traceback (most recent call last):
  File "testing-ground/decimal_jsons_test.py", line 19, in <module>
    a = jsons.load(dictionary, Something)
  File "testing-ground/env/lib/python3.10/site-packages/jsons/_load_impl.py", line 101, in load
    return _do_load(json_obj, deserializer, cls, initial, **kwargs_)
  File "testing-ground/env/lib/python3.10/site-packages/jsons/_load_impl.py", line 113, in _do_load
    result = deserializer(json_obj, cls, **kwargs)
  File "testing-ground/env/lib/python3.10/site-packages/jsons/deserializers/default_object.py", line 40, in default_object_deserializer
    constructor_args = _get_constructor_args(obj, cls, **kwargs)
  File "testing-ground/env/lib/python3.10/site-packages/jsons/deserializers/default_object.py", line 64, in _get_constructor_args
    key, value = _get_value_for_attr(obj=obj,
  File "testing-ground/env/lib/python3.10/site-packages/jsons/deserializers/default_object.py", line 94, in _get_value_for_attr
    result = sig_key, _get_value_from_obj(obj, cls, sig, sig_key,
  File "testing-ground/env/lib/python3.10/site-packages/jsons/deserializers/default_object.py", line 140, in _get_value_from_obj
    value = load(obj[sig_key], cls_, meta_hints=new_hints, **kwargs)
  File "testing-ground/env/lib/python3.10/site-packages/jsons/_load_impl.py", line 83, in load
    cls, meta_hints = _check_and_get_cls_and_meta_hints(
  File "testing-ground/env/lib/python3.10/site-packages/jsons/_load_impl.py", line 200, in _check_and_get_cls_and_meta_hints
    raise DeserializationError(msg, json_obj, cls)
jsons.exceptions.DeserializationError: Invalid type: "decimal.Decimal", only arguments of the following types are allowed: str, int, float, bool, list, tuple, set, dict, NoneType

But JSONS is capable of deserializing this dictionary just fine, we just need to modify the list of types it is supposed to be able to deserialize, here, we just need to add decimal.Decimal to the list of VALID_TYPES

For this code:

import jsons
from decimal import Decimal
from dataclasses import dataclass

dictionary = {
    'value': Decimal(15.0)
}

@dataclass
class Something:
    value: float

a = jsons.load(dictionary, Something)
print(a.value)

Observed behavior: Jsons throws the above exception

Expected behavior: a.value is initialized to 15.0

Thanks

For serialization, one can export an instance of pydantic model to json

from datetime import datetime
from pydantic import BaseModel

class BarModel(BaseModel):
    whatever: int

class FooBarModel(BaseModel):
    foo: datetime
    bar: BarModel


m = FooBarModel(foo=datetime(2032, 6, 1, 12, 13, 14), bar={'whatever': 123})
print(m.json())
#> {"foo": "2032-06-01T12:13:14", "bar": {"whatever": 123}}

For deserialization, one can directly parse string into an instance of pydantic model

from datetime import datetime
from pydantic import BaseModel

class User(BaseModel):
    id: int
    name = 'John Doe'
    signup_ts: datetime = None

m = User.parse_raw('{"id": 123, "name": "James"}')
print(m)
#> id=123 signup_ts=None name='James'

So, why jsons over pydantic?

I can see that jsons being more lightweight for obvious reasons, but I wish to hear from the authors as well!

For some reason I cant seem to get a json dump for a pydantic baseModel class object

eg:

import jsons
from pydantic import BaseModel 

class abc(BaseModel):
    value: int

d = abc(value=1)

jsons.dump(d)

OUTPUT SerializationError: object of type 'abc' has no len()

EXPECTED The object should serialise fine.

This is using jsons-1.6.3 and pydantic-1.9.1

How can one make jsons.dump() treat bytes the same as Python3 str? Some sort of serializer/class/setting change/override, perhaps?

On my system (below) jsons.dump() prints my bytes type variables in a List-like format, even when assigning said variables a str literal (I think... maybe I don't understand Python3 properly? Quite possible). The pertinent excerpt:

"{'originally_bytes_type': ['1', '2', '3', '4'], 'originally_str___type': '1234'}"

All the context:

$ cat jsons-dump-string-type-test.py
#!/usr/bin/env python3

from dataclasses import dataclass
import jsons

@dataclass
class strs_and_bytes:
    originally_bytes_type : bytes
    originally_str___type : str

sandb1 = strs_and_bytes \
(
    originally_bytes_type = '1234' ,
    originally_str___type = '1234' ,
)

print('"' + str(jsons.dump(sandb1)) + '"')
$ python3 jsons-dump-string-type-test.py
"{'originally_bytes_type': ['1', '2', '3', '4'], 'originally_str___type': '1234'}"
$ python3 --version
Python 3.8.10
$ pip3 install josons
^CERROR: Operation cancelled by user
$ pip3 install jsons
Requirement already satisfied: jsons in /usr/local/lib/python3.8/dist-packages (1.6.3)
Requirement already satisfied: typish>=1.9.2 in /usr/local/lib/python3.8/dist-packages (from jsons) (1.9.3)
$ lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 20.04.4 LTS
Release:	20.04
Codename:	focal
$

I implemented these for a project I'm working on that uses jsons, then noticed https://github.com/ramonhagenaars/jsons/issues/170 and figured I may as well see if you like the implementation enough to go with it.

I included the strictly_equal_literal as a compromise between correctness and utility.

From https://peps.python.org/pep-0586/#equivalence-of-two-literals

Two types Literal[v1] and Literal[v2] are equivalent when both of the following conditions are true:

1. type(v1) == type(v2)
2. v1 == v2

I took that to mean that for a value to really match a literal it should match in both type and value. The only problem with that is that I've found it to be very useful to allow jsons to "coerce" values that are equal in value into the literal value, the use case that prompted me to implement this actually relies on that behaviour.

Hi, I have a problem where I'm trying to deserialize nested objects, and have each of their respective load functions trigger.

Code example:

from typing import List
import jsons

class B(jsons.JsonSerializable):
    c: List[str]
    
    @classmethod
    def load(cls, json_obj, **kwargs):
        print("Loading", cls)
        return jsons.load(json_obj, cls, **kwargs)

class A(jsons.JsonSerializable):
    b: B
    
    @classmethod
    def load(cls, json_obj, **kwargs):
        print("Loading", cls)
        return jsons.load(json_obj, cls, **kwargs)

obj = {'b': {'c': ['d', 'd']}}

jsons.load(obj, A) # Nothing printed
A.load(obj) # Only "Loading <class '__main__.A'>" is printed

What I would expect as default behavior in this case is to have both Loading <class ...B> and Loading <class ...A> printed. Is there any way to achieve this behavior?

Thanks!