code-loader 1.0.151.dev3__tar.gz → 1.0.152.dev1__tar.gz

{code_loader-1.0.151.dev3 → code_loader-1.0.152.dev1}/PKG-INFO

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

{code_loader-1.0.151.dev3 → code_loader-1.0.152.dev1}/code_loader/contract/datasetclasses.py

@@ -60,9 +60,14 @@ class PreprocessResponse:
             raise Exception("length is deprecated, please use sample_ids instead.")
 
         if self.state is None:
-            warnings.warn(
-                "PreprocessResponse.state is not set. For best practice, assign a unique `state` value to each PreprocessResponse instance."
+            from code_loader.inner_leap_binder.leapbinder_decorators import store_warning_by_param
+            store_warning_by_param(
+                param_name="PreprocessResponse.state",
+                user_func_name="tensorleap_preprocess",
+                default_value=str("specific order"),
+                link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/preprocess-function",
             )
+
         else:
             assert isinstance(self.state, DataStateType), f"PreprocessResponse.state must be of type {DataStateType.__name__} but got {type(self.state)}"
 
@@ -229,7 +234,8 @@ class CustomLatentSpaceHandler:
 class PredictionTypeHandler:
     name: str
     labels: List[str]
-    channel_dim: int = -1
+    channel_dim: int = "default_value"
+
 
 
 @dataclass

{code_loader-1.0.151.dev3 → code_loader-1.0.152.dev1}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -6,7 +6,7 @@ from collections import defaultdict
 from functools import lru_cache
 from pathlib import Path
 from typing import Optional, Union, Callable, List, Dict, Set, Any
-from typing import Optional, Union, Callable, List, Dict, get_args, get_origin
+from typing import Optional, Union, Callable, List, Dict, get_args, get_origin, DefaultDict
 
 import numpy as np
 import numpy.typing as npt
@@ -28,11 +28,63 @@ from code_loader.mixpanel_tracker import clear_integration_events, AnalyticsEven
 
 import inspect
 import functools
+import __main__
+from pathlib import Path
 
 _called_from_inside_tl_decorator = 0
 _called_from_inside_tl_integration_test_decorator = False
 _call_from_tl_platform = os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true'
 
+# ---- warnings store (module-level) ----
+_UNSET = object()
+_STORED_WARNINGS: List[Dict[str, Any]] = []
+_STORED_WARNING_KEYS: Set[tuple] = set()
+# param_name -> set(user_func_name)
+_PARAM_DEFAULT_FUNCS: DefaultDict[str, Set[str]] = defaultdict(set)
+# param_name -> default_value used (repr-able)
+_PARAM_DEFAULT_VALUE: Dict[str, Any] = {}
+_PARAM_DEFAULT_DOCS: Dict[str, str] = {}
+
+
+def get_entry_script_path() -> str:
+    return getattr(__main__, "__file__", "") or ""
+
+
+def started_from(filename: str) -> bool:
+    entry = get_entry_script_path()
+    return bool(entry) and Path(entry).name == filename
+
+
+def store_warning_by_param(
+        *,
+        param_name: str,
+        user_func_name: str,
+        default_value: Any,
+        link_to_docs: str = None,
+) -> None:
+    _PARAM_DEFAULT_FUNCS[param_name].add(user_func_name)
+
+    if param_name not in _PARAM_DEFAULT_VALUE:
+        _PARAM_DEFAULT_VALUE[param_name] = default_value
+
+    if link_to_docs and param_name not in _PARAM_DEFAULT_DOCS:
+        _PARAM_DEFAULT_DOCS[param_name] = link_to_docs
+
+
+def _get_param_default_warnings() -> Dict[str, Dict[str, Any]]:
+    out: Dict[str, Dict[str, Any]] = {}
+    for p, funcs in _PARAM_DEFAULT_FUNCS.items():
+        out[p] = {
+            "default_value": _PARAM_DEFAULT_VALUE.get(p, None),
+            "funcs": set(funcs),
+            "link_to_docs": _PARAM_DEFAULT_DOCS.get(p),
+        }
+    return out
+
+
+def _get_stored_warnings() -> List[Dict[str, Any]]:
+    return list(_STORED_WARNINGS)
+
 
 def validate_args_structure(*args, types_order, func_name, expected_names, **kwargs):
     def _type_to_str(t):
@@ -173,6 +225,8 @@ def tensorleap_integration_test():
             )
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_integration_test')
             validate_args_structure(*args, types_order=[Union[int, str], PreprocessResponse],
                                     func_name='integration_test', expected_names=["idx", "preprocess"], **kwargs)
             _validate_input_args(*args, **kwargs)
@@ -228,7 +282,18 @@ def _safe_get_item(key):
         raise Exception(f'Tensorleap currently supports models with no more then 10 inputs')
 
 
-def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]] = []):
+def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]] = _UNSET):
+    prediction_types_was_provided = prediction_types is not _UNSET
+
+    if not prediction_types_was_provided:
+        prediction_types = []
+        if not _call_from_tl_platform:
+            store_warning_by_param(
+                param_name="prediction_types",
+                user_func_name="tensorleap_load_model",
+                default_value=prediction_types,
+                link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/integration-test#tensorleap_load_model"
+            )
     assert isinstance(prediction_types, list), (
         f"tensorleap_load_model validation failed: "
         f" prediction_types is an optional argument of type List[PredictionTypeHandler]] but got {type(prediction_types).__name__}."
@@ -236,6 +301,16 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
     for i, prediction_type in enumerate(prediction_types):
         assert isinstance(prediction_type, PredictionTypeHandler), (f"tensorleap_load_model validation failed: "
                                                                     f" prediction_types at position {i} must be of type PredictionTypeHandler but got {type(prediction_types[i]).__name__}.")
+        prediction_type_channel_dim_was_provided = prediction_type.channel_dim != "default_value"
+        if not prediction_type_channel_dim_was_provided:
+            prediction_types[i].channel_dim = -1
+            if not _call_from_tl_platform:
+                store_warning_by_param(
+                    param_name=f"prediction_types[{i}].channel_dim",
+                    user_func_name="tensorleap_load_model",
+                    default_value=prediction_types[i].channel_dim,
+                    link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/integration-test#tensorleap_load_model"
+                )
         leap_binder.add_prediction(prediction_type.name, prediction_type.labels, prediction_type.channel_dim, i)
 
     def _validate_result(result) -> None:
@@ -274,6 +349,8 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
 
         @lru_cache()
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_load_model')
             validate_args_structure(*args, types_order=[],
                                     func_name='tensorleap_load_model', expected_names=[], **kwargs)
 
@@ -437,7 +514,7 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
 
 
 def tensorleap_custom_metric(name: str,
-                             direction: Union[MetricDirection, Dict[str, MetricDirection]] = MetricDirection.Downward,
+                             direction: Union[MetricDirection, Dict[str, MetricDirection]] = _UNSET,
                              compute_insights: Optional[Union[bool, Dict[str, bool]]] = None,
                              connects_to=None):
     name_to_unique_name = defaultdict(set)
@@ -445,6 +522,20 @@ def tensorleap_custom_metric(name: str,
     def decorating_function(
             user_function: Union[CustomCallableInterfaceMultiArgs, CustomMultipleReturnCallableInterfaceMultiArgs,
             ConfusionMatrixCallableInterfaceMultiArgs]):
+        nonlocal direction
+
+        direction_was_provided = direction is not _UNSET
+
+        if not direction_was_provided:
+            direction = MetricDirection.Downward
+            if not _call_from_tl_platform:
+                store_warning_by_param(
+                    param_name="direction",
+                    user_func_name=user_function.__name__,
+                    default_value=direction,
+                    link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/custom-metrics"
+
+                )
 
         def _validate_decorators_signature():
             err_message = f"{user_function.__name__} validation failed.\n"
@@ -637,6 +728,8 @@ def tensorleap_custom_metric(name: str,
             _add_mapping_connections(connects_to, arg_names, NodeMappingType.Metric, name)
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_custom_metric')
             _validate_input_args(*args, **kwargs)
 
             result = inner_without_validate(*args, **kwargs)
@@ -686,7 +779,6 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
         assert isinstance(visualizer_type, LeapDataType), (f"{user_function.__name__} validation failed: "
                                                            f"visualizer_type should be of type {LeapDataType.__name__} but got {type(visualizer_type)}"
                                                            )
-
         for viz_handler in leap_binder.setup_container.visualizers:
             if viz_handler.visualizer_handler_data.name == name:
                 raise Exception(f'Visualizer with name {name} already exists. '
@@ -759,6 +851,8 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
             _add_mapping_connections(connects_to, arg_names, NodeMappingType.Visualizer, name)
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_custom_visualizer')
             _validate_input_args(*args, **kwargs)
 
             result = inner_without_validate(*args, **kwargs)
@@ -844,6 +938,8 @@ def tensorleap_metadata(
         leap_binder.set_metadata(inner_without_validate, name, metadata_type)
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_metadata')
             if os.environ.get(mapping_runtime_mode_env_var_mame):
                 return None
             validate_args_structure(*args, types_order=[Union[int, str], PreprocessResponse],
@@ -937,6 +1033,8 @@ def tensorleap_preprocess():
                  f'The return list should not contain duplicate PreprocessResponse objects.')
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_metadata')
             if os.environ.get(mapping_runtime_mode_env_var_mame):
                 return [None, None, None, None]
 
@@ -1145,12 +1243,27 @@ def tensorleap_instances_length_encoder(name: str):
     return decorating_function
 
 
-def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
+def tensorleap_input_encoder(name: str, channel_dim=_UNSET, model_input_index=None):
     def decorating_function(user_function: SectionCallableInterface):
         for input_handler in leap_binder.setup_container.inputs:
             if input_handler.name == name:
                 raise Exception(f'Input with name {name} already exists. '
                                 f'Please choose another')
+        nonlocal channel_dim
+
+        channel_dim_was_provided = channel_dim is not _UNSET
+
+        if not channel_dim_was_provided:
+            channel_dim = -1
+            if not _call_from_tl_platform:
+                store_warning_by_param(
+                    param_name="channel_dim",
+                    user_func_name=user_function.__name__,
+                    default_value=channel_dim,
+                    link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/input-encoder"
+
+                )
+
         if channel_dim <= 0 and channel_dim != -1:
             raise Exception(f"Channel dim for input {name} is expected to be either -1 or positive")
 
@@ -1185,6 +1298,8 @@ def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
         leap_binder.set_input(inner_without_validate, name, channel_dim=channel_dim)
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current("tensorleap_input_encoder")
             validate_args_structure(*args, types_order=[Union[int, str], PreprocessResponse],
                                     func_name=user_function.__name__, expected_names=["idx", "preprocess"], **kwargs)
             sample_id, preprocess_response = args if len(args) != 0 else kwargs.values()
@@ -1278,6 +1393,8 @@ def tensorleap_gt_encoder(name: str):
         leap_binder.set_ground_truth(inner_without_validate, name)
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current("tensorleap_gt_encoder")
             validate_args_structure(*args, types_order=[Union[int, str], PreprocessResponse],
                                     func_name=user_function.__name__, expected_names=["idx", "preprocess"], **kwargs)
             sample_id, preprocess_response = args
@@ -1385,6 +1502,8 @@ def tensorleap_custom_loss(name: str, connects_to=None):
             _add_mapping_connections(connects_to, arg_names, NodeMappingType.CustomLoss, name)
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current("tensorleap_custom_loss")
             _validate_input_args(*args, **kwargs)
 
             result = inner_without_validate(*args, **kwargs)
@@ -1452,47 +1571,97 @@ def tensorleap_custom_layer(name: str):
 
 
 def tensorleap_status_table():
-    '''
-    Usage example:
-    ###################
-    leap_integration.py
-    ###################
-    from code_loader.inner_leap_binder.leapbinder_decorators import tensorleap_status_table
-    ...
-    ...
-    ...
-    if __name__ == '__main__':
-        tensorleap_status_table()
-        ...
-    '''
     import atexit
     import sys
     import traceback
+    from typing import Any
+
     CHECK = "✅"
     CROSS = "❌"
+    UNKNOWN = "❔"
+
     code_mapping_failure = [0]
-    table = [
-        {"name": "tensorleap_preprocess", "Added to integration": CROSS},
-        {"name": "tensorleap_integration_test", "Added to integration": CROSS},
-        {"name": "tensorleap_input_encoder", "Added to integration": CROSS},
-        {"name": "tensorleap_gt_encoder", "Added to integration": CROSS},
-        {"name": "tensorleap_load_model", "Added to integration": CROSS},
-        {"name": "tensorleap_custom_loss", "Added to integration": CROSS},
-        {"name": "tensorleap_custom_metric (optional)", "Added to integration": CROSS},
-        {"name": "tensorleap_metadata (optional)", "Added to integration": CROSS},
-        {"name": "tensorleap_custom_visualizer (optional)", "Added to integration": CROSS},
 
+    table = [
+        {"name": "tensorleap_preprocess", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_integration_test", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_input_encoder", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_gt_encoder", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_load_model", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_custom_loss", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_custom_metric (optional)", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_metadata (optional)", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_custom_visualizer (optional)", "Added to integration": UNKNOWN},
     ]
 
     _finalizer_called = {"done": False}
+    _crashed = {"value": False}
+    _current_func = {"name": None}
+
+    def _link(url: str) -> str:
+        return f"\033{url}\033"
 
     def _remove_suffix(s: str, suffix: str) -> str:
-        # This is needed because str.remove_suffix was presented in python3.9+
         if suffix and s.endswith(suffix):
             return s[:-len(suffix)]
         return s
 
+    def _find_row(name: str):
+        for row in table:
+            if _remove_suffix(row["name"], " (optional)") == name:
+                return row
+        return None
+
+    def _set_status(name: str, status_symbol: str):
+        row = _find_row(name)
+        if not row:
+            return
+
+        cur = row["Added to integration"]
+        if status_symbol == UNKNOWN:
+            return
+        if cur == CHECK and status_symbol != CHECK:
+            return
+
+        row["Added to integration"] = status_symbol
+
+    def _mark_unknowns_as_cross():
+        for row in table:
+            if row["Added to integration"] == UNKNOWN:
+                row["Added to integration"] = CROSS
+
+    def _format_default_value(v: Any) -> str:
+        if hasattr(v, "name"):
+            return str(v.name)
+        if isinstance(v, str):
+            return v
+        s = repr(v)
+        return s if len(s) <= 120 else s[:120] + "..."
+
+    def _print_param_default_warnings():
+        data = _get_param_default_warnings()
+        if not data:
+            return
+
+        print("\nWarnings (Default use. It is recommended to set values explicitly):")
+        for param_name in sorted(data.keys()):
+            default_value = data[param_name]["default_value"]
+            funcs = ", ".join(sorted(data[param_name]["funcs"]))
+            dv = _format_default_value(default_value)
+
+            docs_link = data[param_name].get("link_to_docs")
+            docs_part = f" {_link(docs_link)}" if docs_link else ""
+            print(
+                f" ⚠️ Parameter '{param_name}' defaults to {dv} in the following functions: [{funcs}]. "
+                f"For more information, check {docs_part}")
+        print("\nIf this isn’t the intended behaviour, set them explicitly.")
+
     def _print_table():
+        _print_param_default_warnings()
+
+        if not started_from("leap_integration.py"):
+            return
+
         ready_mess = "\nAll parts have been successfully set. If no errors accured, you can now push the project to the Tensorleap system."
         not_ready_mess = "\nSome mandatory components have not yet been added to the Integration test. Recommended next interface to add is: "
         mandatory_ready_mess = "\nAll mandatory parts have been successfully set. If no errors accured, you can now push the project to the Tensorleap system or continue to the next optional reccomeded interface,adding: "
@@ -1500,48 +1669,75 @@ def tensorleap_status_table():
 
         name_width = max(len(row["name"]) for row in table)
         status_width = max(len(row["Added to integration"]) for row in table)
+
         header = f"{'Decorator Name'.ljust(name_width)} | {'Added to integration'.ljust(status_width)}"
         sep = "-" * len(header)
+
         print("\n" + header)
         print(sep)
+
         ready = True
+        next_step = None
+
         for row in table:
             print(f"{row['name'].ljust(name_width)} | {row['Added to integration'].ljust(status_width)}")
-            if row['Added to integration'] == CROSS and ready:
-                ready = False
-                next_step = row['name']
+            if not _crashed["value"] and ready:
+                if row["Added to integration"] != CHECK:
+                    ready = False
+                    next_step = row["name"]
+
+        if _crashed["value"]:
+            print(f"\nScript crashed before completing all steps. crashed at function '{_current_func['name']}'.")
+            return
 
         if code_mapping_failure[0]:
             print(f"\n{CROSS + code_mapping_failure_mes}.")
-        else:
-            print(ready_mess) if ready else print(
-                mandatory_ready_mess + next_step) if "optional" in next_step else print(not_ready_mess + next_step)
+            return
 
-    def update_env_params(name: str, status: str = "✓"):
-        for row in table:
-            if _remove_suffix(row["name"], " (optional)") == name:
-                row["Added to integration"] = CHECK if status == "v" else CROSS
-                break
+        print(ready_mess) if ready else print(
+            mandatory_ready_mess + next_step
+        ) if (next_step and "optional" in next_step) else print(not_ready_mess + (next_step or ""))
+
+    def set_current(name: str):
+        _current_func["name"] = name
+
+    def update_env_params(name: str, status: str = "v"):
         if name == "code_mapping":
             code_mapping_failure[0] = 1
+        if status == "v":
+            _set_status(name, CHECK)
+        else:
+            _set_status(name, CROSS)
 
     def run_on_exit():
         if _finalizer_called["done"]:
             return
         _finalizer_called["done"] = True
+        if not _crashed["value"]:
+            _mark_unknowns_as_cross()
+
         _print_table()
 
     def handle_exception(exc_type, exc_value, exc_traceback):
+        _crashed["value"] = True
+        crashed_name = _current_func["name"]
+        if crashed_name:
+            row = _find_row(crashed_name)
+            if row and row["Added to integration"] != CHECK:
+                row["Added to integration"] = CROSS
+
         traceback.print_exception(exc_type, exc_value, exc_traceback)
         run_on_exit()
 
     atexit.register(run_on_exit)
     sys.excepthook = handle_exception
-    return update_env_params
+
+    return set_current, update_env_params
 
 
 if not _call_from_tl_platform:
-    update_env_params_func = tensorleap_status_table()
+    set_current, update_env_params_func = tensorleap_status_table()
+
 
 
 

{code_loader-1.0.151.dev3 → code_loader-1.0.152.dev1}/code_loader/leaploader.py

@@ -521,11 +521,11 @@ class LeapLoader(LeapLoaderBase):
 
         return converted_value, is_none
 
-    def get_metadata(self, state: DataStateEnum, sample_id: Union[int, str], only_metadata_names: Optional[List[str]] = None) -> Tuple[
+    def get_metadata(self, state: DataStateEnum, sample_id: Union[int, str], requested_metadata_names: Optional[List[str]] = None) -> Tuple[
         Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
 
         def is_metadata_name_starts_with_handler_name(_handler):
-            for metadata_name in only_metadata_names:
+            for metadata_name in requested_metadata_names:
                 if metadata_name.startswith(_handler.name + '_') or metadata_name == _handler.name:
                     return True
             return False
@@ -535,7 +535,7 @@ class LeapLoader(LeapLoaderBase):
         preprocess_result = self._preprocess_result()
         preprocess_state = preprocess_result[state]
         for handler in global_leap_binder.setup_container.metadata:
-            if only_metadata_names:
+            if requested_metadata_names:
                 if not is_metadata_name_starts_with_handler_name(handler):
                     continue
 
@@ -543,15 +543,15 @@ class LeapLoader(LeapLoaderBase):
             if isinstance(handler_result, dict):
                 for single_metadata_name, single_metadata_result in handler_result.items():
                     handler_name = f'{handler.name}_{single_metadata_name}'
-                    if only_metadata_names:
-                        if handler_name not in only_metadata_names:
+                    if requested_metadata_names:
+                        if handler_name not in requested_metadata_names:
                             continue
                     result_agg[handler_name], is_none[handler_name] = self._convert_metadata_to_correct_type(
                         handler_name, single_metadata_result)
             else:
                 handler_name = handler.name
-                if only_metadata_names:
-                    if handler_name not in only_metadata_names:
+                if requested_metadata_names:
+                    if handler_name not in requested_metadata_names:
                         continue
                 result_agg[handler_name], is_none[handler_name] = self._convert_metadata_to_correct_type(
                     handler_name, handler_result)

{code_loader-1.0.151.dev3 → code_loader-1.0.152.dev1}/code_loader/leaploaderbase.py

@@ -69,7 +69,7 @@ class LeapLoaderBase:
         pass
 
     def get_metadata_multiple_samples(self, state: DataStateEnum, sample_ids: Union[List[int], List[str]],
-                     only_metadata_names: Optional[List[str]] = None
+                                      requested_metadata_names: Optional[List[str]] = None
                                       ) -> Tuple[Dict[str, Union[List[str], List[int], List[bool],
     List[float]]], Dict[str, List[bool]]]:
         aggregated_results: Dict[str, List[Union[str, int, bool, float]]] = {}
@@ -77,7 +77,7 @@ class LeapLoaderBase:
         sample_id_type = self.get_sample_id_type()
         for sample_id in sample_ids:
             sample_id = sample_id_type(sample_id)
-            metadata_result, is_none_result = self.get_metadata(state, sample_id, only_metadata_names)
+            metadata_result, is_none_result = self.get_metadata(state, sample_id, requested_metadata_names)
             for metadata_name, metadata_value in metadata_result.items():
                 if metadata_name not in aggregated_results:
                     aggregated_results[metadata_name] = []
@@ -108,7 +108,7 @@ class LeapLoaderBase:
     @abstractmethod
     def get_metadata(
             self, state: DataStateEnum, sample_id: Union[int, str],
-            only_metadata_names: Optional[List[str]] = None
+            requested_metadata_names: Optional[List[str]] = None
     ) -> Tuple[Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
         pass
 

{code_loader-1.0.151.dev3 → code_loader-1.0.152.dev1}/pyproject.toml

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