Upload renderers.py with huggingface_hub

renderers.py

@@ -1,11 +1,11 @@
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List
+from abc import ABC
+from typing import Any, Dict, List, Optional
 
 from .dataclass import InternalField
 from .formats import Format, ICLFormat
 from .instructions import Instruction
-from .operator import Operator, SequntialOperator, StreamInstanceOperator
-from .random_utils import random
+from .operator import Operator, SequentialOperator, StreamInstanceOperator
+from .random_utils import get_random
 from .templates import Template
 
 
@@ -21,7 +21,9 @@ class RenderTemplate(Renderer, StreamInstanceOperator):
     random_reference: bool = False
     skip_rendered_instance: bool = True
 
-    def process(self, instance: Dict[str, Any], stream_name: str = None) -> Dict[str, Any]:
+    def process(
+        self, instance: Dict[str, Any], stream_name: Optional[str] = None
+    ) -> Dict[str, Any]:
         if self.skip_rendered_instance:
             if (
                 "inputs" not in instance
@@ -32,16 +34,17 @@ class RenderTemplate(Renderer, StreamInstanceOperator):
             ):
                 return instance
 
-        inputs = instance.pop("inputs")
-        outputs = instance.pop("outputs")
+        inputs = instance["inputs"]
+        outputs = instance["outputs"]
 
         source = self.template.process_inputs(inputs)
         targets = self.template.process_outputs(outputs)
 
         if self.template.is_multi_reference:
+            assert isinstance(targets, list), f"{targets} must be a list"
             references = targets
             if self.random_reference:
-                target = random.choice(references)
+                target = get_random().choice(references)
             else:
                 if len(references) == 0:
                     raise ValueError("No references found")
@@ -64,7 +67,9 @@ class RenderTemplate(Renderer, StreamInstanceOperator):
 class RenderDemonstrations(RenderTemplate):
     demos_field: str
 
-    def process(self, instance: Dict[str, Any], stream_name: str = None) -> Dict[str, Any]:
+    def process(
+        self, instance: Dict[str, Any], stream_name: Optional[str] = None
+    ) -> Dict[str, Any]:
         demos = instance.get(self.demos_field, [])
 
         processed_demos = []
@@ -80,7 +85,9 @@ class RenderDemonstrations(RenderTemplate):
 class RenderInstruction(Renderer, StreamInstanceOperator):
     instruction: Instruction
 
-    def process(self, instance: Dict[str, Any], stream_name: str = None) -> Dict[str, Any]:
+    def process(
+        self, instance: Dict[str, Any], stream_name: Optional[str] = None
+    ) -> Dict[str, Any]:
         if self.instruction is not None:
             instance["instruction"] = self.instruction()
         else:
@@ -92,16 +99,20 @@ class RenderFormat(Renderer, StreamInstanceOperator):
     format: Format
     demos_field: str = None
 
-    def process(self, instance: Dict[str, Any], stream_name: str = None) -> Dict[str, Any]:
+    def process(
+        self, instance: Dict[str, Any], stream_name: Optional[str] = None
+    ) -> Dict[str, Any]:
         demos_instances = instance.pop(self.demos_field, None)
         if demos_instances is not None:
-            instance["source"] = self.format.format(instance, demos_instances=demos_instances)
+            instance["source"] = self.format.format(
+                instance, demos_instances=demos_instances
+            )
         else:
             instance["source"] = self.format.format(instance)
         return instance
 
 
-class StandardRenderer(Renderer, SequntialOperator):
+class StandardRenderer(Renderer, SequentialOperator):
     template: Template
     instruction: Instruction = None
     demos_field: str = None