fixed bug in allowing inherited GenericType to be optional. since the typing.Optional annotation is stripped off of the parents we needed to pass on the optional metadata to override the typing check.

Author: ncilfone

spock/backend/config.py

@@ -38,6 +38,7 @@ def _base_attr(cls, kw_only, make_init, dynamic):
     bases = ()
     base_annotation = {}
     base_defaults = {}
+    base_optional = {}
     if len(cls.__mro__[1:-1]) > 0:
         # Get bases minus self and python class object
         bases = list(cls.__mro__[1:-1])
@@ -64,6 +65,10 @@ def _base_attr(cls, kw_only, make_init, dynamic):
                         base_annotation.update(
                             {attribute.name: val.__annotations__[attribute.name]}
                         )
+                    if "optional" in attribute.metadata:
+                        base_optional.update(
+                            {attribute.name: attribute.metadata["optional"]}
+                        )
         base_defaults = {
             attribute.name: attribute.default
             for val in bases
@@ -120,7 +125,13 @@ def _base_attr(cls, kw_only, make_init, dynamic):
             default = base_defaults[k]
         else:
             default = None
-        attrs_dict.update({k: katra(typed=v, default=default)})
+        # If the parent was optional then set the child to optional
+        optional = False
+        if k in base_optional:
+            optional = base_optional[k]
+        attrs_dict.update(
+            {k: katra(typed=v, default=default, inherit_optional=optional)}
+        )
     return bases, attrs_dict, merged_annotations
 
 

spock/backend/typed.py

@@ -561,23 +561,28 @@ def _callable_katra(typed, default=None, optional=False):
     return x
 
 
-def katra(typed, default=None):
+def katra(typed, default=None, inherit_optional=False):
     """Public interface to create a katra
 
-    A 'katra' is the basic functional unit of `spock`. It defines a parameter using attrs as the backend, type checks
-    both simple types and subscripted GenericAlias types (e.g. lists and tuples), handles setting default parameters,
+    A 'katra' is the basic functional unit of `spock`. It defines a parameter using
+    attrs as the backend, type checks both simple types and subscripted GenericAlias
+    types (e.g. lists and tuples), handles setting default parameters,
     and deals with parameter optionality
 
     Args:
         typed: the type of the parameter to define
         default: the default value to assign if given
+        inherit_optional: optionality from inheritance
 
     Returns:
         x: Attribute from attrs
 
     """
     # Handle optionals
     typed, optional = _handle_optional_typing(typed)
+    # Since we strip away the optional typing notation for Generics -- we need to
+    # override with optional coming from the parent
+    optional = True if (optional or inherit_optional) else False
     # Checks for callables via the different Variadic types across versions
     if isinstance(typed, _SpockVariadicGenericAlias):
         x = _callable_katra(typed=typed, default=default, optional=optional)

spock/builder.py

@@ -24,6 +24,7 @@
 from spock.backend.wrappers import Spockspace
 from spock.exceptions import _SpockCryptoError, _SpockEvolveError, _SpockValueError
 from spock.handlers import YAMLHandler
+from spock.helpers import to_dict
 from spock.utils import (
     _C,
     _T,
@@ -635,32 +636,13 @@ def obj_2_dict(self, obj: Union[_C, List[_C], Tuple[_C, ...]]) -> Dict[str, Dict
         """Converts spock classes from a Spockspace into their dictionary representations
 
         Args:
-            objs: single spock class or an iterable of spock classes
+            obj: single spock class or an iterable of spock classes
 
         Returns:
             dictionary where the class names are keys and the values are the dictionary representations
         """
-
-        from spock.helpers import to_dict
-
         return to_dict(obj, self._saver_obj)
 
-        # if isinstance(obj, (List, Tuple)):
-        #     obj_dict = {}
-        #     for val in obj:
-        #         if not _is_spock_instance(val):
-        #             raise _SpockValueError(
-        #                 f"Object is not a @spock decorated class object -- currently `{type(val)}`"
-        #             )
-        #         obj_dict.update({type(val).__name__: val})
-        # elif _is_spock_instance(obj):
-        #     obj_dict = {type(obj).__name__: obj}
-        # else:
-        #     raise _SpockValueError(
-        #         f"Object is not a @spock decorated class object -- currently `{type(obj)}`"
-        #     )
-        # return self.spockspace_2_dict(Spockspace(**obj_dict))
-
     def evolve(self, *args: _C) -> Spockspace:
         """Function that allows a user to evolve the underlying spock classes with
         instantiated spock objects

tests/base/attr_configs_test.py

@@ -393,6 +393,11 @@ class TypeInherited(TypeConfig, TypeDefaultOptConfig):
     pass
 
 
+@spock
+class TypeOptionalInherited(TypeOptConfig):
+    pass
+
+
 class Foo:
     p: int = 1
 

tests/base/test_loaders.py

@@ -60,6 +60,7 @@ def arg_builder(monkeypatch):
             m.setattr(sys, "argv", ["", "--config", "./tests/conf/yaml/inherited.yaml"])
             config = ConfigArgBuilder(
                 TypeInherited,
+                TypeOptionalInherited,
                 NestedStuff,
                 NestedStuffOpt,
                 NestedListStuff,