code-loader 1.0.56__tar.gz → 1.0.58__tar.gz

{code_loader-1.0.56 → code_loader-1.0.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.56
+Version: 1.0.58
 Summary: 
 Home-page: https://github.com/tensorleap/code-loader
 License: MIT

code_loader-1.0.58/code_loader/dualstream.py

@@ -0,0 +1,32 @@
+from io import StringIO
+from typing import IO
+
+
+class DualStream(StringIO):
+    def __init__(self, stream1: IO[str], stream2: StringIO):
+        super().__init__()
+        self.stream1 = stream1  # Usually sys.stdout
+        self.stream2 = stream2  # The StringIO stream
+
+    def write(self, s: str) -> int:
+        # Write to both streams and return the length of the written string
+        self.stream1.write(s)
+        self.stream2.write(s)
+        return len(s)
+
+    def flush(self) -> None:
+        self.stream1.flush()
+        self.stream2.flush()
+
+    def close(self) -> None:
+        # Do not close sys.stdout
+        self.stream2.close()
+
+    def readable(self) -> bool:
+        return False
+
+    def writable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return False

{code_loader-1.0.56 → code_loader-1.0.58}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -52,20 +52,30 @@ def tensorleap_custom_metric(name: str, direction: Optional[MetricDirection] = M
                                        f'Metric has returned unsupported type. Supported types are List[float], '
                                        f'List[List[ConfusionMatrixElement]], NDArray[np.float32]. ')
 
-            if isinstance(result, list):
-                if isinstance(result[0], list):
-                    assert isinstance(result[0][0], ConfusionMatrixElement), \
-                        f'{supported_types_message}Got List[List[{type(result[0][0])}]].'
+            def _validate_single_metric(single_metric_result):
+                if isinstance(single_metric_result, list):
+                    if isinstance(single_metric_result[0], list):
+                        assert isinstance(single_metric_result[0][0], ConfusionMatrixElement), \
+                            f'{supported_types_message}Got List[List[{type(single_metric_result[0][0])}]].'
+                    else:
+                        assert isinstance(single_metric_result[0], float), f'{supported_types_message}Got List[{type(single_metric_result[0])}].'
                 else:
-                    assert isinstance(result[0], float), f'{supported_types_message}Got List[{type(result[0])}].'
+                    assert isinstance(single_metric_result, np.ndarray), f'{supported_types_message}Got {type(single_metric_result)}.'
+                    assert len(single_metric_result.shape) == 1, (f'tensorleap_custom_metric validation failed: '
+                                                    f'The return shape should be 1D. Got {len(single_metric_result.shape)}D.')
 
+                if leap_binder.batch_size_to_validate:
+                    assert len(single_metric_result) == leap_binder.batch_size_to_validate, \
+                        f'tensorleap_custom_metrix validation failed: The return len should be as the batch size.'
+
+            if isinstance(result, dict):
+                for key, value in result.items():
+                    assert isinstance(key, str), \
+                        (f'tensorleap_custom_metric validation failed: '
+                         f'Keys in the return dict should be of type str. Got {type(key)}.')
+                    _validate_single_metric(value)
             else:
-                assert isinstance(result, np.ndarray), f'{supported_types_message}Got {type(result)}.'
-                assert len(result.shape) == 1, (f'tensorleap_custom_metric validation failed: '
-                                                f'The return shape should be 1D. Got {len(result.shape)}D.')
-            if leap_binder.batch_size_to_validate:
-                assert len(result) == leap_binder.batch_size_to_validate, \
-                    f'tensorleap_custom_metrix validation failed: The return len should be as the batch size.'
+                _validate_single_metric(result)
 
         def inner(*args, **kwargs):
             _validate_input_args(*args, **kwargs)

{code_loader-1.0.56 → code_loader-1.0.58}/code_loader/leaploader.py

@@ -19,6 +19,7 @@ from code_loader.contract.exceptions import DatasetScriptException
 from code_loader.contract.responsedataclasses import DatasetIntegParseResult, DatasetTestResultPayload, \
     DatasetPreprocess, DatasetSetup, DatasetInputInstance, DatasetOutputInstance, DatasetMetadataInstance, \
     VisualizerInstance, PredictionTypeInstance, ModelSetup, CustomLayerInstance, MetricInstance, CustomLossInstance
+from code_loader.dualstream import DualStream
 from code_loader.inner_leap_binder import global_leap_binder
 from code_loader.utils import get_root_exception_file_and_line_number
 
@@ -123,8 +124,9 @@ class LeapLoader:
         test_payloads: List[DatasetTestResultPayload] = []
         setup_response = None
         general_error = None
-        stdout_steam = io.StringIO()
-        with redirect_stdout(stdout_steam):
+        stdout_stream = io.StringIO()
+        dual_stream = DualStream(sys.stdout, stdout_stream)
+        with redirect_stdout(dual_stream):
             try:
                 self.exec_script()
                 preprocess_test_payload = self._check_preprocess()
@@ -142,7 +144,7 @@ class LeapLoader:
                 general_error = f"Something went wrong. {repr(e.__cause__)} in file {file_name}, line_number:  {line_number}\nStacktrace:\n{stacktrace}"
                 is_valid = False
 
-        print_log = stdout_steam.getvalue()
+        print_log = dual_stream.stream2.getvalue()
         is_valid_for_model = bool(global_leap_binder.setup_container.custom_layers)
         model_setup = self.get_model_setup_response()
 

{code_loader-1.0.56 → code_loader-1.0.58}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "code-loader"
-version = "1.0.56"
+version = "1.0.58"
 description = ""
 authors = ["dorhar <doron.harnoy@tensorleap.ai>"]
 license = "MIT"

code_loader-1.0.56/code_loader/code_inegration_processes_manager.py

@@ -1,83 +0,0 @@
-# mypy: ignore-errors
-import traceback
-from dataclasses import dataclass
-
-from typing import List, Tuple, Optional
-
-from multiprocessing import Process, Queue
-
-from code_loader.leap_loader_parallelized_base import LeapLoaderParallelizedBase
-from code_loader.leaploader import LeapLoader
-from code_loader.contract.enums import DataStateEnum
-from code_loader.metric_calculator_parallelized import MetricCalculatorParallelized
-from code_loader.samples_generator_parallelized import SamplesGeneratorParallelized
-
-
-@dataclass
-class SampleSerializableError:
-    state: DataStateEnum
-    index: int
-    leap_script_trace: str
-    exception_as_str: str
-
-
-class CodeIntegrationProcessesManager:
-    def __init__(self, code_path: str, code_entry_name: str, n_workers: Optional[int] = 2,
-                 max_samples_in_queue: int = 128) -> None:
-        self.metric_calculator_parallelized = MetricCalculatorParallelized(code_path, code_entry_name)
-        self.samples_generator_parallelized = SamplesGeneratorParallelized(code_path, code_entry_name)
-
-    def _create_and_start_process(self) -> Process:
-        process = self.multiprocessing_context.Process(
-            target=CodeIntegrationProcessesManager._process_func,
-            args=(self.code_path, self.code_entry_name, self._inputs_waiting_to_be_process,
-                  self._ready_processed_results))
-        process.daemon = True
-        process.start()
-        return process
-
-    def _run_and_warm_first_process(self):
-        process = self._create_and_start_process()
-        self.processes = [process]
-
-        # needed in order to make sure the preprocess func runs once in nonparallel
-        self._start_process_inputs([(DataStateEnum.training, 0)])
-        self._get_next_ready_processed_result()
-
-    def _operation_decider(self):
-        if self.metric_calculator_parallelized._ready_processed_results.empty() and not \
-            self.metric_calculator_parallelized._inputs_waiting_to_be_process.empty():
-            return 'metric'
-
-        if self.samples_generator_parallelized._ready_processed_results.empty() and not \
-            self.samples_generator_parallelized._inputs_waiting_to_be_process.empty():
-            return 'dataset'
-
-
-
-
-    @staticmethod
-    def _process_func(code_path: str, code_entry_name: str,
-                      samples_to_process: Queue, ready_samples: Queue,
-                      metrics_to_process: Queue, ready_metrics: Queue) -> None:
-        import os
-        os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
-
-        leap_loader = LeapLoader(code_path, code_entry_name)
-        while True:
-
-            # decide on sample or metric to process
-            state, idx = samples_to_process.get(block=True)
-            leap_loader._preprocess_result()
-            try:
-                sample = leap_loader.get_sample(state, idx)
-            except Exception as e:
-                leap_script_trace = traceback.format_exc().split('File "<string>"')[-1]
-                ready_samples.put(SampleSerializableError(state, idx, leap_script_trace, str(e)))
-                continue
-
-            ready_samples.put(sample)
-
-    def generate_samples(self, sample_identities: List[Tuple[DataStateEnum, int]]):
-        return self.start_process_inputs(sample_identities)
-