Upload dataclass.py with huggingface_hub

dataclass.py

@@ -1,7 +1,6 @@
 import copy
 import dataclasses
 from abc import ABCMeta
-from copy import deepcopy
 from typing import Any, final
 
 _FIELDS = "__fields__"
@@ -9,8 +8,7 @@ _FIELDS = "__fields__"
 
 @dataclasses.dataclass
 class Field:
-    """
-    An alternative to dataclasses.dataclass decorator for a more flexible field definition.
+    """An alternative to dataclasses.dataclass decorator for a more flexible field definition.
 
     Attributes:
         default (Any, optional): Default value for the field. Defaults to None.
@@ -38,8 +36,7 @@ class Field:
     def get_default(self):
         if self.default_factory is not None:
             return self.default_factory()
-        else:
-            return self.default
+        return self.default
 
 
 @dataclasses.dataclass
@@ -107,8 +104,7 @@ standart_variables = dir(object)
 
 
 def is_possible_field(field_name, field_value):
-    """
-    Check if a name-value pair can potentially represent a field.
+    """Check if a name-value pair can potentially represent a field.
 
     Args:
         field_name (str): The name of the field.
@@ -117,12 +113,15 @@ def is_possible_field(field_name, field_value):
     Returns:
         bool: True if the name-value pair can represent a field, False otherwise.
     """
-    return field_name not in standart_variables and not field_name.startswith("__") and not callable(field_value)
+    return (
+        field_name not in standart_variables
+        and not field_name.startswith("__")
+        and not callable(field_value)
+    )
 
 
 def get_fields(cls, attrs):
-    """
-    Get the fields for a class based on its attributes.
+    """Get the fields for a class based on its attributes.
 
     Args:
         cls (type): The class to get the fields for.
@@ -191,15 +190,16 @@ def get_fields(cls, attrs):
 
 
 def is_dataclass(obj):
-    """Returns True if obj is a dataclass or an instance of a
-    dataclass."""
+    """Returns True if obj is a dataclass or an instance of a dataclass."""
     cls = obj if isinstance(obj, type) else type(obj)
     return hasattr(cls, _FIELDS)
 
 
 def class_fields(obj):
     all_fields = fields(obj)
-    return [field for field in all_fields if field.origin_cls == obj.__class__.__qualname__]
+    return [
+        field for field in all_fields if field.origin_cls == obj.__class__.__qualname__
+    ]
 
 
 def fields(cls):
@@ -233,31 +233,36 @@ def is_final_field(field):
 def get_field_default(field):
     if field.default_factory is not None:
         return field.default_factory()
-    else:
-        return field.default
+
+    return field.default
 
 
 def asdict(obj):
-    assert is_dataclass(obj), f"{obj} must be a dataclass, got {type(obj)} with bases {obj.__class__.__bases__}"
+    assert is_dataclass(
+        obj
+    ), f"{obj} must be a dataclass, got {type(obj)} with bases {obj.__class__.__bases__}"
     return _asdict_inner(obj)
 
 
 def _asdict_inner(obj):
     if is_dataclass(obj):
         return obj.to_dict()
-    elif isinstance(obj, tuple) and hasattr(obj, "_fields"):  # named tuple
+
+    if isinstance(obj, tuple) and hasattr(obj, "_fields"):  # named tuple
         return type(obj)(*[_asdict_inner(v) for v in obj])
-    elif isinstance(obj, (list, tuple)):
+
+    if isinstance(obj, (list, tuple)):
         return type(obj)([_asdict_inner(v) for v in obj])
-    elif isinstance(obj, dict):
+
+    if isinstance(obj, dict):
         return type(obj)({_asdict_inner(k): _asdict_inner(v) for k, v in obj.items()})
-    else:
-        return copy.deepcopy(obj)
+
+    return copy.deepcopy(obj)
 
 
 class DataclassMeta(ABCMeta):
-    """
-    Metaclass for Dataclass.
+    """Metaclass for Dataclass.
+
     Checks for final fields when a subclass is created.
     """
 
@@ -268,7 +273,8 @@ class DataclassMeta(ABCMeta):
 
 
 class Dataclass(metaclass=DataclassMeta):
-    """
+    """Base class for data-like classes that provides additional functionality and control.
+
     Base class for data-like classes that provides additional functionality and control
     over Python's built-in @dataclasses.dataclass decorator. Other classes can inherit from
     this class to get the benefits of this implementation. As a base class, it ensures that
@@ -324,7 +330,7 @@ class Dataclass(metaclass=DataclassMeta):
             pass
 
         grand_child = GrandChild()
-        print(grand_child.to_dict())
+        logging.info(grand_child.to_dict())
         ```
 
     """
@@ -333,17 +339,21 @@ class Dataclass(metaclass=DataclassMeta):
 
     @final
     def __init__(self, *argv, **kwargs):
-        """
-        Initialize fields based on 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]
         _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]
+        _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}'")
+                raise TypeError(
+                    f"{self.__class__.__name__} got multiple values for argument '{name}'"
+                )
 
         expected_unexpected_argv = kwargs.pop("_argv", None)
 
@@ -360,11 +370,15 @@ class Dataclass(metaclass=DataclassMeta):
 
         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"]
+            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())
+            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."
@@ -416,31 +430,21 @@ class Dataclass(metaclass=DataclassMeta):
         return True
 
     def __pre_init__(self, **kwargs):
-        """
-        Pre initialization hook.
-        """
+        """Pre initialization hook."""
         pass
 
     def __post_init__(self):
-        """
-        Post initialization hook.
-        """
+        """Post initialization hook."""
         pass
 
     def _to_raw_dict(self):
-        """
-        Convert to raw dict
-        """
+        """Convert to raw dict."""
         return {field.name: getattr(self, field.name) for field in fields(self)}
 
     def to_dict(self):
-        """
-        Convert to dict.
-        """
+        """Convert to dict."""
         return _asdict_inner(self._to_raw_dict())
 
     def __repr__(self) -> str:
-        """
-        String representation.
-        """
-        return f"{self.__class__.__name__}({', '.join([f'{field.name}={repr(getattr(self, field.name))}' for field in fields(self)])})"
+        """String representation."""
+        return f"{self.__class__.__name__}({', '.join([f'{field.name}={getattr(self, field.name)!r}' for field in fields(self)])})"