Distinguish between optional and required fields on csp structs

[p72dennisxu]

Currently any field on a csp struct could be unset, which means that to avoid AttributeErrors at runtime, the user would need to manually perform the hasattr check every time. To improve this, we could add a new metaclass parameter allow_unset that defaults to True (for backwards compatibility) and when set to False enforces the following new semantics:

• If a field has the type T, then it's required on struct creation (currently it would be optional). If the user does not pass in a value and there's no default value, a TypeError will be raised.
• If a field has the type Optional[T] or T | None, then it's not required to be set and defaults to None.

For example, under the new rules, the following struct definition

class MyStruct(csp.Struct, allow_unset=False):
    x: int
    y: Optional[str]

would imply that MyStruct(x=3) is valid with y=None but MyStruct(y="hello") would raise something like TypeError: MyStruct missing 1 required field: 'x' (int).

[robambalu]

This was internally discussed and agreed upon. Here are some notes that came from the meeting:

• allow_unset - naming open for discussion, but opt in method will be done as a metaclass option
• When opting in, all fields that are not defaulted will be required to be passed into the struct init method. This includes Optional fields that arent defaulted to None.
• On the C++ side we'll need to validate all fields are set when structs are constructed ( this may require updates to autogen ). Dynamic adapters that map fields to dynamically defined structs will need to add a validation step.
• When accessing "strict" struct fields at graph time as a ts only non-optional fields will be allowed, otherwise raise at wiring time
• fromts - needs to raise if all non-defaulted fields dont tick together
• for strict structs fields cannot be deleted, del attr should raise. Another point on this is that hasattr will always be true for "strict" structs if the field is defined on the struct
• Make sure to_dict / from_dict behave as expected

[AdamGlustein]

Adding in the pseudocode that was discussed for future references

class A(csp.Struct, allow_unset=False):
    x: int # required field, will raise if ever unset
    y: Optional[str] = None # optional field, if accessed at runtime without a value, will return None
    z: str | None # equivalent syntax for an optional field

If allow_unset=False all fields of the struct will always pass hasattr checks, and del field is not allowed. The user should instead do struct.field = None.