Upload dataclass.py with huggingface_hub

dataclass.py

@@ -235,11 +235,7 @@ def asdict(obj):
 
 def _asdict_inner(obj):
     if is_dataclass(obj):
-        result = {}
-        for field in fields(obj):
-            v = getattr(obj, field.name)
-            result[field.name] = _asdict_inner(v)
-        return result
+        return obj.to_dict()
     elif isinstance(obj, tuple) and hasattr(obj, "_fields"):  # named tuple
         return type(obj)(*[_asdict_inner(v) for v in obj])
     elif isinstance(obj, (list, tuple)):
@@ -340,16 +336,36 @@ class Dataclass(metaclass=DataclassMeta):
             if name in kwargs:
                 raise TypeError(f"{self.__class__.__name__} got multiple values for argument '{name}'")
 
+        expected_unexpected_argv = kwargs.pop("_argv", None)
+
         if len(argv) <= len(_init_positional_fields_names):
             unexpected_argv = []
         else:
             unexpected_argv = argv[len(_init_positional_fields_names) :]
 
-        unexpected_kwargs = {k: v for k, v in kwargs.items() if k not in _init_fields_names}
+        if expected_unexpected_argv is not None:
+            assert (
+                len(unexpected_argv) == 0
+            ), f"Cannot specify both _argv and unexpected positional arguments. Got {unexpected_argv}"
+            unexpected_argv = tuple(expected_unexpected_argv)
+
+        expected_unexpected_kwargs = kwargs.pop("_kwargs", None)
+        unexpected_kwargs = {
+            k: v for k, v in kwargs.items() if k not in _init_fields_names and k not in ["_argv", "_kwargs"]
+        }
+
+        if expected_unexpected_kwargs is not None:
+            intersection = set(unexpected_kwargs.keys()) & set(expected_unexpected_kwargs.keys())
+            assert (
+                len(intersection) == 0
+            ), f"Cannot specify the same arguments in both _kwargs and in unexpected keyword arguments. Got {intersection} in both."
+            unexpected_kwargs = {**unexpected_kwargs, **expected_unexpected_kwargs}
 
         if self.__allow_unexpected_arguments__:
-            self._argv = unexpected_argv
-            self._kwargs = unexpected_kwargs
+            if len(unexpected_argv) > 0:
+                kwargs["_argv"] = unexpected_argv
+            if len(unexpected_kwargs) > 0:
+                kwargs["_kwargs"] = unexpected_kwargs
 
         else:
             if len(unexpected_argv) > 0:
@@ -376,12 +392,12 @@ class Dataclass(metaclass=DataclassMeta):
                     f"Required field '{field.name}' of class {field.origin_cls} not set in {self.__class__.__name__}"
                 )
 
+        self.__pre_init__(**kwargs)
+
         for field in fields(self):
             if field.name in kwargs:
                 setattr(self, field.name, kwargs[field.name])
             else:
-                if field.name in ["_argv", "_kwargs"] and self.__allow_unexpected_arguments__:
-                    continue
                 setattr(self, field.name, get_field_default(field))
 
         self.__post_init__()
@@ -390,17 +406,29 @@ class Dataclass(metaclass=DataclassMeta):
     def __is_dataclass__(self) -> bool:
         return True
 
+    def __pre_init__(self, **kwargs):
+        """
+        Pre initialization hook.
+        """
+        pass
+
     def __post_init__(self):
         """
         Post initialization hook.
         """
         pass
 
+    def _to_raw_dict(self):
+        """
+        Convert to raw dict
+        """
+        return {field.name: getattr(self, field.name) for field in fields(self)}
+
     def to_dict(self):
         """
         Convert to dict.
         """
-        return asdict(self)
+        return _asdict_inner(self._to_raw_dict())
 
     def __repr__(self) -> str:
         """