Module dataclasses_json.api

View Source
import abc

import json

from enum import Enum

from typing import (Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar,

                    Union)

from stringcase import (camelcase, pascalcase, snakecase,

                        spinalcase)  # type: ignore

from dataclasses_json.cfg import config

from dataclasses_json.core import (Json, _ExtendedEncoder, _asdict,

                                   _decode_dataclass)

from dataclasses_json.mm import (JsonData, SchemaType, build_schema)

from dataclasses_json.undefined import Undefined

from dataclasses_json.utils import (_handle_undefined_parameters_safe,

                                    _undefined_parameter_action_safe)

A = TypeVar('A', bound="DataClassJsonMixin")

B = TypeVar('B')

C = TypeVar('C')

Fields = List[Tuple[str, Any]]

class LetterCase(Enum):

    CAMEL = camelcase

    KEBAB = spinalcase

    SNAKE = snakecase

    PASCAL = pascalcase

class DataClassJsonMixin(abc.ABC):

    """

    DataClassJsonMixin is an ABC that functions as a Mixin.

    As with other ABCs, it should not be instantiated directly.

    """

    dataclass_json_config = None

    def to_json(self,

                *,

                skipkeys: bool = False,

                ensure_ascii: bool = True,

                check_circular: bool = True,

                allow_nan: bool = True,

                indent: Optional[Union[int, str]] = None,

                separators: Tuple[str, str] = None,

                default: Callable = None,

                sort_keys: bool = False,

                **kw) -> str:

        return json.dumps(self.to_dict(encode_json=False),

                          cls=_ExtendedEncoder,

                          skipkeys=skipkeys,

                          ensure_ascii=ensure_ascii,

                          check_circular=check_circular,

                          allow_nan=allow_nan,

                          indent=indent,

                          separators=separators,

                          default=default,

                          sort_keys=sort_keys,

                          **kw)

    @classmethod

    def from_json(cls: Type[A],

                  s: JsonData,

                  *,

                  parse_float=None,

                  parse_int=None,

                  parse_constant=None,

                  infer_missing=False,

                  **kw) -> A:

        kvs = json.loads(s,

                         parse_float=parse_float,

                         parse_int=parse_int,

                         parse_constant=parse_constant,

                         **kw)

        return cls.from_dict(kvs, infer_missing=infer_missing)

    @classmethod

    def from_dict(cls: Type[A],

                  kvs: Json,

                  *,

                  infer_missing=False) -> A:

        return _decode_dataclass(cls, kvs, infer_missing)

    def to_dict(self, encode_json=False) -> Dict[str, Json]:

        return _asdict(self, encode_json=encode_json)

    @classmethod

    def schema(cls: Type[A],

               *,

               infer_missing: bool = False,

               only=None,

               exclude=(),

               many: bool = False,

               context=None,

               load_only=(),

               dump_only=(),

               partial: bool = False,

               unknown=None) -> SchemaType:

        Schema = build_schema(cls, DataClassJsonMixin, infer_missing, partial)

        if unknown is None:

            undefined_parameter_action = _undefined_parameter_action_safe(cls)

            if undefined_parameter_action is not None:

                # We can just make use of the same-named mm keywords

                unknown = undefined_parameter_action.name.lower()

        return Schema(only=only,

                      exclude=exclude,

                      many=many,

                      context=context,

                      load_only=load_only,

                      dump_only=dump_only,

                      partial=partial,

                      unknown=unknown)

def dataclass_json(_cls=None, *, letter_case=None,

                   undefined: Optional[Union[str, Undefined]] = None):

    """

    Based on the code in the `dataclasses` module to handle optional-parens

    decorators. See example below:

    @dataclass_json

    @dataclass_json(letter_case=LetterCase.CAMEL)

    class Example:

        ...

    """

    def wrap(cls):

        return _process_class(cls, letter_case, undefined)

    if _cls is None:

        return wrap

    return wrap(_cls)

def _process_class(cls, letter_case, undefined):

    if letter_case is not None or undefined is not None:

        cls.dataclass_json_config = config(letter_case=letter_case,

                                           undefined=undefined)[

            'dataclasses_json']

    cls.to_json = DataClassJsonMixin.to_json

    # unwrap and rewrap classmethod to tag it to cls rather than the literal

    # DataClassJsonMixin ABC

    cls.from_json = classmethod(DataClassJsonMixin.from_json.__func__)

    cls.to_dict = DataClassJsonMixin.to_dict

    cls.from_dict = classmethod(DataClassJsonMixin.from_dict.__func__)

    cls.schema = classmethod(DataClassJsonMixin.schema.__func__)

    cls.__init__ = _handle_undefined_parameters_safe(cls, kvs=(), usage="init")

    # register cls as a virtual subclass of DataClassJsonMixin

    DataClassJsonMixin.register(cls)

    return cls

Variables

A
B
C
Fields

Functions

dataclass_json

def dataclass_json(
    _cls=None,
    *,
    letter_case=None,
    undefined: Union[str, dataclasses_json.undefined.Undefined, NoneType] = None
)

Based on the code in the dataclasses module to handle optional-parens decorators. See example below:

@dataclass_json @dataclass_json(letter_case=LetterCase.CAMEL) class Example: ...

View Source
def dataclass_json(_cls=None, *, letter_case=None,

                   undefined: Optional[Union[str, Undefined]] = None):

    """

    Based on the code in the `dataclasses` module to handle optional-parens

    decorators. See example below:

    @dataclass_json

    @dataclass_json(letter_case=LetterCase.CAMEL)

    class Example:

        ...

    """

    def wrap(cls):

        return _process_class(cls, letter_case, undefined)

    if _cls is None:

        return wrap

    return wrap(_cls)

Classes

DataClassJsonMixin

class DataClassJsonMixin(
    /,
    *args,
    **kwargs
)

DataClassJsonMixin is an ABC that functions as a Mixin.

As with other ABCs, it should not be instantiated directly.

View Source
class DataClassJsonMixin(abc.ABC):

    """

    DataClassJsonMixin is an ABC that functions as a Mixin.

    As with other ABCs, it should not be instantiated directly.

    """

    dataclass_json_config = None

    def to_json(self,

                *,

                skipkeys: bool = False,

                ensure_ascii: bool = True,

                check_circular: bool = True,

                allow_nan: bool = True,

                indent: Optional[Union[int, str]] = None,

                separators: Tuple[str, str] = None,

                default: Callable = None,

                sort_keys: bool = False,

                **kw) -> str:

        return json.dumps(self.to_dict(encode_json=False),

                          cls=_ExtendedEncoder,

                          skipkeys=skipkeys,

                          ensure_ascii=ensure_ascii,

                          check_circular=check_circular,

                          allow_nan=allow_nan,

                          indent=indent,

                          separators=separators,

                          default=default,

                          sort_keys=sort_keys,

                          **kw)

    @classmethod

    def from_json(cls: Type[A],

                  s: JsonData,

                  *,

                  parse_float=None,

                  parse_int=None,

                  parse_constant=None,

                  infer_missing=False,

                  **kw) -> A:

        kvs = json.loads(s,

                         parse_float=parse_float,

                         parse_int=parse_int,

                         parse_constant=parse_constant,

                         **kw)

        return cls.from_dict(kvs, infer_missing=infer_missing)

    @classmethod

    def from_dict(cls: Type[A],

                  kvs: Json,

                  *,

                  infer_missing=False) -> A:

        return _decode_dataclass(cls, kvs, infer_missing)

    def to_dict(self, encode_json=False) -> Dict[str, Json]:

        return _asdict(self, encode_json=encode_json)

    @classmethod

    def schema(cls: Type[A],

               *,

               infer_missing: bool = False,

               only=None,

               exclude=(),

               many: bool = False,

               context=None,

               load_only=(),

               dump_only=(),

               partial: bool = False,

               unknown=None) -> SchemaType:

        Schema = build_schema(cls, DataClassJsonMixin, infer_missing, partial)

        if unknown is None:

            undefined_parameter_action = _undefined_parameter_action_safe(cls)

            if undefined_parameter_action is not None:

                # We can just make use of the same-named mm keywords

                unknown = undefined_parameter_action.name.lower()

        return Schema(only=only,

                      exclude=exclude,

                      many=many,

                      context=context,

                      load_only=load_only,

                      dump_only=dump_only,

                      partial=partial,

                      unknown=unknown)

Ancestors (in MRO)

  • abc.ABC

Class variables

dataclass_json_config

Static methods

from_dict
def from_dict(
    kvs: Union[dict, list, str, int, float, bool, NoneType],
    *,
    infer_missing=False
) -> ~A
View Source
    @classmethod

    def from_dict(cls: Type[A],

                  kvs: Json,

                  *,

                  infer_missing=False) -> A:

        return _decode_dataclass(cls, kvs, infer_missing)
from_json
def from_json(
    s: Union[str, bytes, bytearray],
    *,
    parse_float=None,
    parse_int=None,
    parse_constant=None,
    infer_missing=False,
    **kw
) -> ~A
View Source
    @classmethod

    def from_json(cls: Type[A],

                  s: JsonData,

                  *,

                  parse_float=None,

                  parse_int=None,

                  parse_constant=None,

                  infer_missing=False,

                  **kw) -> A:

        kvs = json.loads(s,

                         parse_float=parse_float,

                         parse_int=parse_int,

                         parse_constant=parse_constant,

                         **kw)

        return cls.from_dict(kvs, infer_missing=infer_missing)
schema
def schema(
    *,
    infer_missing: bool = False,
    only=None,
    exclude=(),
    many: bool = False,
    context=None,
    load_only=(),
    dump_only=(),
    partial: bool = False,
    unknown=None
) -> dataclasses_json.mm.SchemaF[~A]
View Source
    @classmethod

    def schema(cls: Type[A],

               *,

               infer_missing: bool = False,

               only=None,

               exclude=(),

               many: bool = False,

               context=None,

               load_only=(),

               dump_only=(),

               partial: bool = False,

               unknown=None) -> SchemaType:

        Schema = build_schema(cls, DataClassJsonMixin, infer_missing, partial)

        if unknown is None:

            undefined_parameter_action = _undefined_parameter_action_safe(cls)

            if undefined_parameter_action is not None:

                # We can just make use of the same-named mm keywords

                unknown = undefined_parameter_action.name.lower()

        return Schema(only=only,

                      exclude=exclude,

                      many=many,

                      context=context,

                      load_only=load_only,

                      dump_only=dump_only,

                      partial=partial,

                      unknown=unknown)

Methods

to_dict
def to_dict(
    self,
    encode_json=False
) -> Dict[str, Union[dict, list, str, int, float, bool, NoneType]]
View Source
    def to_dict(self, encode_json=False) -> Dict[str, Json]:

        return _asdict(self, encode_json=encode_json)
to_json
def to_json(
    self,
    *,
    skipkeys: bool = False,
    ensure_ascii: bool = True,
    check_circular: bool = True,
    allow_nan: bool = True,
    indent: Union[int, str, NoneType] = None,
    separators: Tuple[str, str] = None,
    default: Callable = None,
    sort_keys: bool = False,
    **kw
) -> str
View Source
    def to_json(self,

                *,

                skipkeys: bool = False,

                ensure_ascii: bool = True,

                check_circular: bool = True,

                allow_nan: bool = True,

                indent: Optional[Union[int, str]] = None,

                separators: Tuple[str, str] = None,

                default: Callable = None,

                sort_keys: bool = False,

                **kw) -> str:

        return json.dumps(self.to_dict(encode_json=False),

                          cls=_ExtendedEncoder,

                          skipkeys=skipkeys,

                          ensure_ascii=ensure_ascii,

                          check_circular=check_circular,

                          allow_nan=allow_nan,

                          indent=indent,

                          separators=separators,

                          default=default,

                          sort_keys=sort_keys,

                          **kw)

LetterCase

class LetterCase(
    /,
    *args,
    **kwargs
)

An enumeration.

View Source
class LetterCase(Enum):

    CAMEL = camelcase

    KEBAB = spinalcase

    SNAKE = snakecase

    PASCAL = pascalcase

Ancestors (in MRO)

  • enum.Enum

Class variables

CAMEL
KEBAB
PASCAL
SNAKE
name
value