marshmallow-dataclass

Update VERSION, (hopefully) really publish 8.6.1

• This adds the ability to include non init-ed fields into the schema

• Pin typing-extensions>=2.4.0 to ensure support for the field_specifiers paramter of the dataclass_transform decorator. (#240)

• Tighten pin on typing-inspect in an attempt to prevent breakage from a hypothetical major version bump.

• Tighten pin on typeguard to exclude older versions for which our tests fail.

• Fix to allow type-checkers to properly handle fields initialized by a dataclasses.Field instance. (#239)

• Fixes to work with typeguard 3.x. (#235, #234)
• Add the @dataclass_transform decorator (PEP 681) to marshmallow_dataclass.dataclass. This fixes our mypy plugin for mypy>=1.1.1.

• Replace the use of marshmallow-enum with the native marshmallow.field.Enum (when using a sufficiently recent version of marshmallow). (#227, #225)

• We now test under python version 3.11 (as well as 3.6 through 3.10). (#220)

• Recognize the variable-length, homogeneous tuple types Tuple[T, ...] (and tuple[T, ...] under python >= 3.8). These are equivalent to the previously recognized Sequence[T]. (#221)

• Recognize PEP 604, T | U, union notation (requires python >= 3.10). Fixes #194. (#219)

• Fix #206: NewType breakage with typing-inspect>=0.8.0 (#207, #211)
• Fix tests for python 3.11 (#212)

• Fix https://github.com/lovasoa/marshmallow_dataclass/issues/190

• Fix bug introduced in previous release. See https://github.com/lovasoa/marshmallow_dataclass/pull/189

• Fix slowdown introduced in v8.5.4. See https://github.com/lovasoa/marshmallow_dataclass/pull/187

• Add support for the Final type. See #150 and #151
• Add support for forward references and Postponed Evaluation of Annotations. (See #13)
• update dependencies

• Fix spurious ValueError when defining a Union field with explicit default value (#161)

• Fix spurious TypeError when serializing Optional union types with required=True (#160)

• Allow setting required=True on fields of type Optional (#159)

• Fix default warning coming from marshmallow. Bump minimal marshmallow version requirement to 3.13. See #157.
• Add support for the Final type. See #150

• Compatibility with python3.9 lowercase type annotations. See #136

• Fix compatibility with older python versions.

• Add support for multiple collections.abc containers :
  • Mapping
  • Sequence
  • Set
  • FrozenSet
  • (see #131)

You can now write :

from marshmallow_dataclass import dataclass
from collections.abc import Sequence, Mapping, Set

@dataclass
class FrozenData:
   seq: Sequence[int] # like List[int], but immutable 
   map: Mapping[str, int] # like Dict[str, int], but immutable 
   set: Set[int] # like List[int], but unordered

f: FrozenData = FrozenData.Schema().load({"seq":[1], "map":{"x":2}, "set":[2]})
print(f.seq[0]) # -> 1
print(f.map["x"]) # -> 2
print(2 in f.set) # -> True

• Fix package license field

• Allow None in Optional fields. See #108

• Export pre-built Email and Url types. See #115

• Add support for the Literal type. See #110

• Improved support for Optional types

• Better support for unions (See #93).
• Added support for validator stacking. This breaks backwards compatability. See https://github.com/lovasoa/marshmallow_dataclass/issues/91.

  What this means:

  CustomType = NewType("CustomType", str, validate=marshmallow.validate.Length(min=3))
  
  
  @dataclass
  class CustomObject:
      some_field: CustomType = field(metadata={"validate": marshmallow.validate.URL()})
  

  The following code will produce a field with the following list of validators: [marshmallow.validate.Length(min=3), marshmallow.validate.URL()] instead of the previous: [marshmallow.validate.URL()].

• Allow setting a custom marshmallow field for collection types. This lets you write code such as :

  class FilteringListField(ListField):
      def __init__(self, cls: Union[Field, type], min: typing.Any, **kwargs):
          super().__init__(cls, **kwargs)
          self.min = min
  
      def _deserialize(self, value, attr, data, **kwargs) -> typing.List[typing.Any]:
          loaded = super(FilteringListField, self)._deserialize(
              value, attr, data, **kwargs
          )
          return [x for x in loaded if self.min <= x]
  
  
  class BaseSchema(Schema):
      TYPE_MAPPING = {typing.List: FilteringListField}
  
  
  @dataclasses.dataclass
  class WithCustomField:
      constrained_floats: typing.List[float] = dataclasses.field(metadata={"min": 1})
  
  
  schema = class_schema(WithCustomField, base_schema=BaseSchema)()
  schema.load({"constrained_floats": [0, 1, 2, 3]})
  # -> WithCustomField(constrained_floats=[1.0, 2.0, 3.0])
  

  (See #66)

• Fix fields of type Any incorrectly always rejecting the value None. None can still be disallowed by explicitly setting the marshmallow attribute allow_none=False. (#80)

• Fix an inconsistency in the behavior of marshmallow.post_load. The input to post_load hooks was either a dict or a dataclass instance depending on the method name. It is now always a dict. (#75)

• Allow the use of BaseSchema to specify a custom mapping from python types to marshmallow fields (#72)

• Cache the generated schemas (#70)

• Exclude the test subdirectory from the published package. (#59)

• Add mypy plugin that handles NewType (#50). Thanks @selimb.

• Fix behavior when base_schema is passed to a nested dataclass/schema (#52). Thanks @ADR-007-SoftServe for the catch and patch.

• Improved documentation
• The library now has more unit tests
• dict and list without type parameters are now supported

This is now supported

from marshmallow_dataclass import dataclass


@dataclass
class Environment:
    env_variables: dict

However, we do still recommend you to always use explicit type parameters, that is:

from marshmallow_dataclass import dataclass
from typing import Dict


@dataclass
class Environment:
    env_variables: Dict[str, str]

• Methods are not copied from the dataclass to the generated Schema anymore. (See #47). This breaks backward compatibility, but hopefully should not impact anyone since marshmallow-specific methods are still copied.

This does not work anymore:

from marshmallow_dataclass import dataclass

@dataclass
class C:
    def say_hello():
       print("hello")

C.Schema.say_hello()

But this still works as expected:

from marshmallow_dataclass import dataclass
from marshmallow import validates, ValidationError

@dataclass
class C:
    name: str
    @validates('name')
    def validates(self, value):
        if len(name) > 10: raise ValidationError("name too long")

• custom base schema
• NewType declarations

• Dropped compatibility with marshmallow 2.

• Added support for the Any type