Upload artifact.py with huggingface_hub

artifact.py

@@ -1,21 +1,22 @@
 import difflib
 import inspect
 import json
+import logging
 import os
 import pkgutil
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from copy import deepcopy
-from typing import Any, Dict, List, Union, final
+from typing import Dict, List, Union, final
 
-from .dataclass import Dataclass, Field, asdict, fields
+from .dataclass import Dataclass, Field, fields
 from .text_utils import camel_to_snake_case, is_camel_case
 from .type_utils import issubtype
 
 
-class Artifactories(object):
+class Artifactories:
     def __new__(cls):
         if not hasattr(cls, "instance"):
-            cls.instance = super(Artifactories, cls).__new__(cls)
+            cls.instance = super().__new__(cls)
             cls.instance.artifactories = []
 
         return cls.instance
@@ -27,15 +28,27 @@ class Artifactories(object):
         return next(self.artifactories)
 
     def register(self, artifactory):
-        assert isinstance(artifactory, Artifactory), "Artifactory must be an instance of Artifactory"
-        assert hasattr(artifactory, "__contains__"), "Artifactory must have __contains__ method"
-        assert hasattr(artifactory, "__getitem__"), "Artifactory must have __getitem__ method"
-        self.artifactories = [artifactory] + self.artifactories
+        assert isinstance(
+            artifactory, Artifactory
+        ), "Artifactory must be an instance of Artifactory"
+        assert hasattr(
+            artifactory, "__contains__"
+        ), "Artifactory must have __contains__ method"
+        assert hasattr(
+            artifactory, "__getitem__"
+        ), "Artifactory must have __getitem__ method"
+        self.artifactories = [artifactory, *self.artifactories]
 
     def unregister(self, artifactory):
-        assert isinstance(artifactory, Artifactory), "Artifactory must be an instance of Artifactory"
-        assert hasattr(artifactory, "__contains__"), "Artifactory must have __contains__ method"
-        assert hasattr(artifactory, "__getitem__"), "Artifactory must have __getitem__ method"
+        assert isinstance(
+            artifactory, Artifactory
+        ), "Artifactory must be an instance of Artifactory"
+        assert hasattr(
+            artifactory, "__contains__"
+        ), "Artifactory must have __contains__ method"
+        assert hasattr(
+            artifactory, "__getitem__"
+        ), "Artifactory must have __getitem__ method"
         self.artifactories.remove(artifactory)
 
     def reset(self):
@@ -62,7 +75,7 @@ def get_closest_artifact_type(type):
     return None
 
 
-class UnrecognizedArtifactType(ValueError):
+class UnrecognizedArtifactTypeError(ValueError):
     def __init__(self, type) -> None:
         maybe_class = "".join(word.capitalize() for word in type.split("_"))
         message = f"'{type}' is not a recognized artifact 'type'. Make sure a the class defined this type (Probably called '{maybe_class}' or similar) is defined and/or imported anywhere in the code executed."
@@ -72,9 +85,11 @@ class UnrecognizedArtifactType(ValueError):
         super().__init__(message)
 
 
-class MissingArtifactType(ValueError):
+class MissingArtifactTypeError(ValueError):
     def __init__(self, dic) -> None:
-        message = f"Missing 'type' parameter. Expected 'type' in artifact dict, got {dic}"
+        message = (
+            f"Missing 'type' parameter. Expected 'type' in artifact dict, got {dic}"
+        )
         super().__init__(message)
 
 
@@ -90,11 +105,13 @@ class Artifact(Dataclass):
     @classmethod
     def verify_artifact_dict(cls, d):
         if not isinstance(d, dict):
-            raise ValueError(f"Artifact dict <{d}> must be of type 'dict', got '{type(d)}'.")
+            raise ValueError(
+                f"Artifact dict <{d}> must be of type 'dict', got '{type(d)}'."
+            )
         if "type" not in d:
-            raise MissingArtifactType(d)
+            raise MissingArtifactTypeError(d)
         if not cls.is_registered_type(d["type"]):
-            raise UnrecognizedArtifactType(d["type"])
+            raise UnrecognizedArtifactTypeError(d["type"])
 
     @classmethod
     def get_artifact_type(cls):
@@ -130,7 +147,7 @@ class Artifact(Dataclass):
     def is_artifact_file(cls, path):
         if not os.path.exists(path) or not os.path.isfile(path):
             return False
-        with open(path, "r") as f:
+        with open(path) as f:
             d = json.load(f)
         return cls.is_artifact_dict(d)
 
@@ -155,10 +172,9 @@ class Artifact(Dataclass):
             pass
         if cls.is_artifact_dict(d):
             cls.verify_artifact_dict(d)
-            instance = cls._class_register[d.pop("type")](**d)
-            return instance
-        else:
-            return d
+            return cls._class_register[d.pop("type")](**d)
+
+        return d
 
     @classmethod
     def from_dict(cls, d):
@@ -167,7 +183,7 @@ class Artifact(Dataclass):
 
     @classmethod
     def load(cls, path):
-        with open(path, "r") as f:
+        with open(path) as f:
             d = json.load(f)
         return cls.from_dict(d)
 
@@ -186,7 +202,9 @@ class Artifact(Dataclass):
         self.type = self.register_class(self.__class__)
 
         for field in fields(self):
-            if issubtype(field.type, Union[Artifact, List[Artifact], Dict[str, Artifact]]):
+            if issubtype(
+                field.type, Union[Artifact, List[Artifact], Dict[str, Artifact]]
+            ):
                 value = getattr(self, field.name)
                 value = map_values_in_place(value, maybe_recover_artifact)
                 setattr(self, field.name, value)
@@ -200,7 +218,9 @@ class Artifact(Dataclass):
     def save(self, path):
         with open(path, "w") as f:
             init_dict = self.to_dict()
-            json.dump(init_dict, f, indent=4)
+            dumped = json.dumps(init_dict, indent=4)
+            f.write(dumped)
+            f.write("\n")
 
 
 class ArtifactList(list, Artifact):
@@ -231,40 +251,40 @@ class UnitxtArtifactNotFoundError(Exception):
 def fetch_artifact(name):
     if Artifact.is_artifact_file(name):
         return Artifact.load(name), None
-    else:
-        for artifactory in Artifactories():
-            if name in artifactory:
-                return artifactory[name], artifactory
+
+    for artifactory in Artifactories():
+        if name in artifactory:
+            return artifactory[name], artifactory
 
     raise UnitxtArtifactNotFoundError(name, Artifactories().artifactories)
 
 
 def verbosed_fetch_artifact(identifer):
     artifact, artifactory = fetch_artifact(identifer)
-    print(f"Artifact {identifer} is fetched from {artifactory}")
+    logging.info(f"Artifact {identifer} is fetched from {artifactory}")
     return artifact
 
 
 def maybe_recover_artifact(artifact):
     if isinstance(artifact, str):
         return verbosed_fetch_artifact(artifact)
-    else:
-        return artifact
+
+    return artifact
 
 
 def register_all_artifacts(path):
-    for loader, module_name, is_pkg in pkgutil.walk_packages(path):
-        print(__name__)
+    for loader, module_name, _is_pkg in pkgutil.walk_packages(path):
+        logging.info(__name__)
         if module_name == __name__:
             continue
-        print(f"Loading {module_name}")
+        logging.info(f"Loading {module_name}")
         # Import the module
         module = loader.find_module(module_name).load_module(module_name)
 
         # Iterate over every object in the module
-        for name, obj in inspect.getmembers(module):
+        for _name, obj in inspect.getmembers(module):
             # Make sure the object is a class
             if inspect.isclass(obj):
                 # Make sure the class is a subclass of Artifact (but not Artifact itself)
                 if issubclass(obj, Artifact) and obj is not Artifact:
-                    print(obj)
+                    logging.info(obj)