Upload dataclass.py with huggingface_hub

dataclass.py

@@ -27,10 +27,12 @@ class Field:
     name: str = None
     type: type = None
     init: bool = True
+    also_positional: bool = True
     default_factory: Any = None
     final: bool = False
     abstract: bool = False
     required: bool = False
+    internal: bool = False
     origin_cls: type = None
 
     def get_default(self):
@@ -58,6 +60,20 @@ class AbstractField(Field):
         self.abstract = True
 
 
+@dataclasses.dataclass
+class NonPositionalField(Field):
+    def __post_init__(self):
+        self.also_positional = False
+
+
+@dataclasses.dataclass
+class InternalField(Field):
+    def __post_init__(self):
+        self.internal = True
+        self.init = False
+        self.also_positional = False
+
+
 class FinalFieldError(TypeError):
     pass
 
@@ -74,6 +90,10 @@ class TypeMismatchError(TypeError):
     pass
 
 
+class UnexpectedArgumentError(TypeError):
+    pass
+
+
 standart_variables = dir(object)
 
 
@@ -102,17 +122,21 @@ def get_fields(cls, attrs):
     Returns:
         dict: A dictionary mapping field names to Field instances.
     """
-
-    fields = {**getattr(cls, _FIELDS, {})}
+    fields = {}
+    for base in cls.__bases__:
+        fields = {**getattr(base, _FIELDS, {}), **fields}
     annotations = {**attrs.get("__annotations__", {})}
 
     for attr_name, attr_value in attrs.items():
         if attr_name not in annotations and is_possible_field(attr_name, attr_value):
             if attr_name in fields:
-                if not isinstance(attr_value, fields[attr_name].type):
-                    raise TypeMismatchError(
-                        f"Type mismatch for field '{attr_name}' of class '{fields[attr_name].origin_cls}'. Expected {fields[attr_name].type}, got {type(attr_value)}"
-                    )
+                try:
+                    if not isinstance(attr_value, fields[attr_name].type):
+                        raise TypeMismatchError(
+                            f"Type mismatch for field '{attr_name}' of class '{fields[attr_name].origin_cls}'. Expected {fields[attr_name].type}, got {type(attr_value)}"
+                        )
+                except TypeError:
+                    pass
                 annotations[attr_name] = fields[attr_name].type
 
     for field_name, field_type in annotations.items():
@@ -150,6 +174,10 @@ def get_fields(cls, attrs):
         field_instance = Field(**args)
         fields[field_name] = field_instance
 
+        if cls.__allow_unexpected_arguments__:
+            fields["_argv"] = InternalField(name="_argv", type=tuple, default=())
+            fields["_kwargs"] = InternalField(name="_kwargs", type=dict, default={})
+
     return fields
 
 
@@ -296,15 +324,46 @@ class Dataclass(metaclass=DataclassMeta):
 
     """
 
+    __allow_unexpected_arguments__ = False
+
     @final
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *argv, **kwargs):
         """
         Initialize fields based on kwargs.
         Checks for abstract fields when an instance is created.
         """
-        init_fields = [field for field in fields(self) if field.init]
-        for field, arg in zip(init_fields, args):
-            kwargs[field.name] = arg
+        _init_fields = [field for field in fields(self) if field.init]
+        _init_fields_names = [field.name for field in _init_fields]
+        _init_positional_fields_names = [field.name for field in _init_fields if field.also_positional]
+
+        for name in _init_positional_fields_names[: len(argv)]:
+            if name in kwargs:
+                raise TypeError(f"{self.__class__.__name__} got multiple values for argument '{name}'")
+
+        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 self.__allow_unexpected_arguments__:
+            self._argv = unexpected_argv
+            self._kwargs = unexpected_kwargs
+
+        else:
+            if len(unexpected_argv) > 0:
+                raise UnexpectedArgumentError(
+                    f"Too many positional arguments {unexpected_argv} for class {self.__class__.__name__}.\nShould be only {len(_init_positional_fields_names)} positional arguments: {', '.join(_init_positional_fields_names)}"
+                )
+
+            if len(unexpected_kwargs) > 0:
+                raise UnexpectedArgumentError(
+                    f"Unexpected keyword argument(s) {unexpected_kwargs} for class {self.__class__.__name__}.\nShould be one of: {fields_names(self)}"
+                )
+
+        for name, arg in zip(_init_positional_fields_names, argv):
+            kwargs[name] = arg
 
         for field in abstract_fields(self):
             raise AbstractFieldError(
@@ -321,6 +380,8 @@ class Dataclass(metaclass=DataclassMeta):
             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__()