Network commands

[pederhan]

No description provided.

[pederhan]

We can probably simplify the type further by inlining the JSONPrimitive type, but it hampers readability.

Suggested change

	JSONPrimitive = Union[str, int, float, bool, None]
	JSONValue = Union[JSONPrimitive, Mapping[str, "JSONValue"], Sequence["JSONValue"]]
	JSONMapping = Mapping[str, JSONValue]
	JSONValue = Union[Union[str, int, float, bool, None], Mapping[str, "JSONValue"], Sequence["JSONValue"]]
	JSONMapping = Mapping[str, JSONValue]

[terjekv]

Union[Union[str, int, float, bool, None], Mapping[str, "JSONValue"], Sequence["JSONValue"]] makes my eyes, nose, head, and hair hurt. I am however in awe of your ability to express Python types...

(I am fine with the lack of inlining for a slight bit of readability, but either way works.)

[pederhan]

Also, we don't strictly need JSONMapping, since that is part of the JSONValue type, but it could be a very useful shorthand for most places where we accept some sort of JSON data in mapping form. Especially when it comes to avoiding problems stemming from invariant/covariant value types:

def accepts_json_mapping(mapping: Mapping[str, JSONValue]) -> None:
    print(mapping)

def accepts_json_dict(mapping: dict[str, JSONValue]) -> None:
    print(mapping)


d1: dict[str, JSONValue] = {"a": 1, "b": "c", "d": {"e": 2.0}}
accepts_json_mapping(d1)  # OK 
accepts_json_dict(d1)  # OK 


d2: Mapping[str, JSONValue] = {"a": 1, "b": "c", "d": {"e": 2.0}}
accepts_json_mapping(d2)  # OK 
accepts_json_dict(d2)  # error: Invariant ("int | str | dict[str, float]" is not the same as "JSONValue")


d3: dict[str, str] = {"a": "b"}
accepts_json_mapping(d3)  # OK 
accepts_json_dict(d3)  # error: Invariant ("str" is not the same as "JSONValue")


d4: Mapping[str, str] = {"a": "b"}
accepts_json_mapping(d4)  # OK 
accepts_json_dict(d4)  # error: Invariant ("str" is not the same as "JSONValue")

This illustrates how much easier we make it for ourselves by using Mapping annotations where we have complex types, since something like dict[str, str] cannot be passed to a function annotated with dict[str, JSONValue], while it can if the annotation is Mapping[str, JSONValue].

I know this from (painful) first-hand experience, not because of some deep understanding of the type system. 🥲

[terjekv]

The invariant primitives, like dict and list, are weird like this. It's a similar issue where list[Child] isn't an acceptable type declaration for something that expects list[Parent], but it works with Sequence[Child] and Sequence[Parent]. It's... frustrating.

And yeah, I think everyone who knows this found out through (painful) first-hand experience.