Pep 563 defines the ability to lazily define type annotations.

Say I have something like this:

class Foo:
    name: str

class Bar:
    foos: List[Foo]

This would work fine. But what if I am importing from another library, or have them in defined in a different order?

class Bar:
    foos: List[Foo]

class Foo:
    name: str

This will break.

Pep 563 addresses this with from __future__ import annotations. Basically it passes the type annotation as a string to then be resolved at runtime with: typing.get_type_hints().

Therefore, rather than grabbing self.__annotations__, you do something like what I did in pydiggy:

annotations = get_type_hints(self, globalns=globals(), localns=localns)

I think for middle it would be a relatively simple change, but it is a 3.7+ change. Just a thought.

Drop Python 3.5 support for middle - only 4 downloads since December, so there's a lot of code just to support this version whereas the project would have a huge benefit using Python 3.6+ - like f strings.

If possible, fine grain the converters, so a str input value of {} doesn't end up as a str({}) call

Create (optional) input and output argument group for fields or objects to better handle more fine grained use cases, when creating or dumping objects.

Get date and datetime converters to be customizable, instead of an if isinstance statement

Create a proper benchmark suite for middle against other similar solutions

middle should respect and work with proper class inheritance and mro, like being able to "cast" a child object to its parent type (or extract from it) and so on.

The definition above should produce a ValidationError, since it's not Optional, hence the values on given for Tuples must not be null or None.

Implement some sort of filters to display or hide field values depending the situation (input or output), much like marshmallow does

Implement more validators / converters and a subscription like system for more metadata options

Provide better error handling techniques for developers (almost everywhere)

• middle version: 0.2.2
• Python version: 3.7.3
• Operating System: Alpine Linux v3.9

Description

Set a length requirement for a str

What I Did

class Foo(middle.Model):
    bar: str = middle.field(min_length=4, max_length=4)

ValueError: The 'min_length' keyword value must not be equal or greater than the 'max_length' keyword value. 

This seems like it should be possible. Or, perhaps:

bar: str = middle.field(length=4)

• middle version: 0.2.2
• Python version: 3.7
• Operating System: Linux

Description

I tried to implement middle with an Enum that uses EnumMeta to implement a custom metaclass.

What I Did

Traceback (most recent call last):
  File "/tmp/p.py", line 28, in <module>
    class Item(middle.Model):
  File "/home/adam/.virtualenvs/TEMP37/lib/python3.7/site-packages/middle/model.py", line 95, in __new__
    _implement_converters(f, k, annotations)
  File "/home/adam/.virtualenvs/TEMP37/lib/python3.7/site-packages/middle/model.py", line 200, in _implement_converters
    converter_fn = converter(annotations.get(key))
  File "/home/adam/.virtualenvs/TEMP37/lib/python3.7/site-packages/middle/dispatch.py", line 25, in __call__
    return fn(*args)
  File "/home/adam/.virtualenvs/TEMP37/lib/python3.7/site-packages/middle/converters.py", line 154, in converter
    raise InvalidType()
middle.exceptions.InvalidType: The required type is not supported by ``middle``. Please, see https://middle.readthedocs.io/en/latest/extending.html for more information on how to add your own types.

Snippets

Here is the code that produced the exception.

from enum import Enum
from enum import EnumMeta
from enum import auto

import random
import middle


class RandomMetaclass(EnumMeta):
    @property
    def RANDOM(self):
        member_map = [x for x in self._member_map_.values()]
        return random.choice(member_map)


class BaseEnum(Enum, metaclass=RandomMetaclass):
    pass


class Status(BaseEnum):
    DRAFT = auto()
    PROPOSED = auto()
    ACCEPTED = auto()
    REJECTED = auto()
    ABANDONED = auto()


class Item(middle.Model):
    title: str
    status: Status

item = Item(title="FooBar", status=Status.RANDOM)
print(item)

I confirmed that it works if I do not use EnumMeta.

class Status(Enum):
    ...

item = Item(title="FooBar", status=Status.DRAFT)

The snippet provided (if any) can be used to create unit tests for this issue.

Support more types (provided in the Python standard library), if possible, like:

• Any
• Optional
• Union
• Decimal

Add some kind of alias options to populate classes or read data (like author from name, as one example)

This looks like a huge task, so there's no way to "minimize" words without saying that there's a need to drop attrs as a dependency from middle to be able to generate more fined grained classes, aiming Python 3.6+ only and allowing some enhancements, like a better error control system, as described and commented in #4.

No need to provide extra info I guess 😅

Get 100% (or closer) in code coverage