returnn 1.20250122.223647__tar.gz → 1.20250123.173545__tar.gz

{returnn-1.20250122.223647/returnn.egg-info → returnn-1.20250123.173545}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20250122.223647
+Version: 1.20250123.173545
 Summary: The RWTH extensible training framework for universal recurrent neural networks
 Home-page: https://github.com/rwth-i6/returnn/
 Author: Albert Zeyer

returnn-1.20250123.173545/_setup_info_generated.py

@@ -0,0 +1,2 @@
+version = '1.20250123.173545'
+long_version = '1.20250123.173545+git.5dab449'

{returnn-1.20250122.223647 → returnn-1.20250123.173545}/returnn/config.py

@@ -7,13 +7,16 @@ from __future__ import annotations
 __author__ = "Patrick Doetsch"
 __credits__ = ["Patrick Doetsch", "Paul Voigtlaender"]
 
-from typing import Optional, Any, Dict, List
+from typing import TypeVar, Type, Optional, Union, Any, Dict, List, Sequence, Tuple
 import contextlib
 import sys
 import os
 import types as _types
 
 
+T = TypeVar("T")
+
+
 class Config:
     """
     Reads in some config file, and provides access to the key/value items.
@@ -140,11 +143,10 @@ class Config:
             self.add_line(key=line[0], value=line[1])
 
     @classmethod
-    def get_config_file_type(cls, f):
+    def get_config_file_type(cls, f: str) -> str:
         """
-        :param str f: file path
+        :param f: file path
         :return: "py", "js" or "txt"
-        :rtype: str
         """
         with open(f, "r") as f:
             start = f.read(3)
@@ -154,9 +156,9 @@ class Config:
             return "js"
         return "txt"
 
-    def parse_cmd_args(self, args):
+    def parse_cmd_args(self, args: Sequence[str]):
         """
-        :param list[str]|tuple[str] args:
+        :param args:
         """
         from optparse import OptionParser
 
@@ -262,11 +264,12 @@ class Config:
                 value = value[1:]  # otherwise we never could specify things like "++threshold -0.1"
             self.add_line(key=key[2:], value=value)
 
-    def add_line(self, key, value):
+    def add_line(self, key: str, value: str):
         """
         Adds one specific configuration (key,value) pair to the inner set of parameters
-        :type key: str
-        :type value: str
+
+        :param key:
+        :param value:
         """
         if key in self.typed_dict:
             # This is a special case. We overwrite a config value which was typed before.
@@ -300,69 +303,65 @@ class Config:
         else:
             self.dict[key] = value
 
-    def has(self, key):
+    def has(self, key: str) -> bool:
         """
         Returns whether the given key is present in the inner set of parameters
-        :type key: string
-        :rtype: boolean
-        :returns True if and only if the given key is in the inner set of parameters
+
+        :param key:
+        :returns: True if and only if the given key is in the inner set of parameters
         """
         if key in self.typed_dict:
             return True
         return key in self.dict
 
-    def is_typed(self, key):
+    def is_typed(self, key: str) -> bool:
         """
-        :type key: string
-        :rtype: boolean
-        :returns True if and only if the value of the given key has a specified data type
+        :param key:
+        :returns: True if and only if the value of the given key has a specified data type
         """
         return key in self.typed_dict
 
-    def is_true(self, key, default=False):
+    def is_true(self, key: str, default: bool = False) -> bool:
         """
-        :param str key:
-        :param bool default:
+        :param key:
+        :param default:
         :return: bool(value) if it is set or default
-        :rtype: bool
         """
         if self.is_typed(key):
             return bool(self.typed_dict[key])
         return self.bool(key, default=default)
 
-    def is_of_type(self, key, types):
+    def is_of_type(self, key: str, types: Union[type, Tuple[type, ...]]) -> bool:
         """
-        :param str key:
-        :param type|tuple[type] types: for isinstance() check
+        :param key:
+        :param types: for isinstance() check
         :return: whether is_typed(key) is True and isinstance(value, types) is True
-        :rtype: bool
         """
         if key in self.typed_dict:
             return isinstance(self.typed_dict[key], types)
         return False
 
-    def get_of_type(self, key, types, default=None):
+    def get_of_type(self, key: str, types: Union[type, Tuple[type, ...], Type[T]], default: Optional[T] = None) -> T:
         """
         :param str key:
-        :param type|list[type]|T types: for isinstance() check
-        :param T|None default:
+        :param types: for isinstance() check
+        :param default:
         :return: if is_of_type(key, types) is True, returns the value, otherwise default
-        :rtype: T
         """
         if self.is_of_type(key, types):
             return self.typed_dict[key]
         return default
 
-    def set(self, key, value):
+    def set(self, key: str, value: Any):
         """
-        :type key: str
-        :type value: list[str] | str | int | float | bool | dict | None
+        :param key:
+        :param value:
         """
         self.typed_dict[key] = value
 
-    def update(self, dikt):
+    def update(self, dikt: Dict[str, Any]):
         """
-        :type dikt: dict
+        :param dikt: dict
         """
         for key, value in dikt.items():
             self.set(key, value)
@@ -383,13 +382,12 @@ class Config:
 
         setattr(self, "value", wrapped_value_func)
 
-    def value(self, key, default, index=None, list_join_str=","):
+    def value(self, key: str, default: T, index: Optional[int] = None, list_join_str: str = ",") -> Union[T, str]:
         """
-        :type key: str
-        :type default: T
-        :type index: int | None
-        :param str list_join_str:
-        :rtype: str | T
+        :param key:
+        :param default:
+        :param index:
+        :param list_join_str:
         """
         if key in self.typed_dict:
             ls = self.typed_dict[key]
@@ -410,12 +408,11 @@ class Config:
                 return ls[index]
         return default
 
-    def typed_value(self, key, default=None, index=None):
+    def typed_value(self, key: str, default: Optional[T] = None, index: Optional[int] = None) -> Union[T, Any]:
         """
-        :type key: str
-        :type default: T
-        :type index: int | None
-        :rtype: T | typing.Any
+        :param key:
+        :param default:
+        :param index:
         """
         value = self.typed_dict.get(key, default)
         if index is not None:
@@ -426,23 +423,22 @@ class Config:
                 assert index == 0
         return value
 
-    def opt_typed_value(self, key, default=None):
+    def opt_typed_value(self, key: str, default: Optional[T] = None) -> Union[T, Any, str]:
         """
-        :param str key:
-        :param T|None default:
-        :rtype: T|object|str|None
+        :param key:
+        :param default:
         """
         if key in self.typed_dict:
             return self.typed_dict[key]
         return self.value(key, default)
 
-    def int(self, key, default, index=0):
+    def int(self, key: str, default: T, index: int = 0) -> Union[int, T]:
         """
         Parses the value of the given key as integer, returning default if not existent
-        :type key: str
-        :type default: T
-        :type index: int
-        :rtype: int | T
+
+        :param key:
+        :param default:
+        :param index:
         """
         if key in self.typed_dict:
             value = self.typed_value(key, default=default, index=index)
@@ -453,13 +449,13 @@ class Config:
             return int(self.value(key, default, index))
         return default
 
-    def bool(self, key, default, index=0):
+    def bool(self, key: str, default: T, index: int = 0) -> Union[bool, T]:
         """
         Parses the value of the given key as boolean, returning default if not existent
-        :type key: str
-        :type default: T
-        :type index: int
-        :rtype: bool | T
+
+        :param key:
+        :param default:
+        :param index:
         """
         if key in self.typed_dict:
             value = self.typed_value(key, default=default, index=index)
@@ -477,13 +473,12 @@ class Config:
 
         return to_bool(v)
 
-    def bool_or_other(self, key, default=None, index=0):
+    def bool_or_other(self, key: str, default: Optional[T] = None, index: int = 0) -> Union[bool, T, Any]:
         """
-        :param str key:
-        :param T default:
-        :param int index:
+        :param key:
+        :param default:
+        :param index:
         :return: if we have typed value, just as-is. otherwise try to convert to bool. or default if not there.
-        :rtype: bool|T|object
         """
         if key in self.typed_dict:
             return self.typed_value(key, default=default, index=index)
@@ -499,13 +494,13 @@ class Config:
         except ValueError:
             return v
 
-    def float(self, key, default, index=0):
+    def float(self, key: str, default: T, index: int = 0) -> Union[float, T]:
         """
         Parses the value of the given key as float, returning default if not existent
-        :type key: str
-        :type default: T
-        :type index: int
-        :rtype: float | T
+
+        :param key:
+        :param default:
+        :param index:
         """
         if key in self.typed_dict:
             value = self.typed_value(key, default=default, index=index)
@@ -519,11 +514,10 @@ class Config:
             assert isinstance(value, (int, float))
         return value
 
-    def list(self, key, default=None):
+    def list(self, key: str, default: Optional[T] = None) -> Union[List[str], T]:
         """
-        :type key: str
-        :type default: T
-        :rtype: list[str] | T
+        :param key:
+        :param default:
         """
         if default is None:
             default = []
@@ -538,11 +532,10 @@ class Config:
             return default
         return self.dict[key]
 
-    def int_list(self, key, default=None):
+    def int_list(self, key: str, default: Optional[T] = None) -> Union[List[int], T]:
         """
-        :type key: str
-        :type default: T
-        :rtype: list[int] | T
+        :param key:
+        :param default:
         """
         if default is None:
             default = []
@@ -557,11 +550,10 @@ class Config:
             return list(value)
         return [int(x) for x in self.list(key, default)]
 
-    def float_list(self, key, default=None):
+    def float_list(self, key: str, default: Optional[T] = None) -> Union[List[float], T]:
         """
-        :type key: str
-        :type default: T
-        :rtype: list[float] | T
+        :param key:
+        :param default:
         """
         if default is None:
             default = []
@@ -576,11 +568,10 @@ class Config:
             return list(value)
         return [float(x) for x in self.list(key, default)]
 
-    def int_pair(self, key, default=None):
+    def int_pair(self, key: str, default: Optional[Tuple[int, int]] = None) -> Tuple[int, int]:
         """
-        :param str key:
-        :param (int,int)|None default:
-        :rtype: (int,int)
+        :param key:
+        :param default:
         """
         if default is None:
             default = (0, 0)

{returnn-1.20250122.223647 → returnn-1.20250123.173545}/returnn/tensor/_tensor_op_overloads.py

@@ -26,6 +26,7 @@ class _TensorOpOverloadsMixin(_TensorMixinBase):
         log.print_deprecation_warning(
             f"{self} __bool__: Using a Tensor in a boolean context is deprecated.", behavior_version=22
         )
+        return True
 
     # --- comparisons
 

{returnn-1.20250122.223647 → returnn-1.20250123.173545}/returnn/tf/util/basic.py

@@ -352,15 +352,16 @@ class OutputWithActivation:
         return safe_log(self.y)
 
 
-def variable_scalar_summaries_dict(x, name=None):
+def variable_scalar_summaries_dict(
+    x: Union[tf.Tensor, tf.Variable], name: Optional[str] = None
+) -> Dict[str, tf.Tensor]:
     """
     Collects all interesting information about `x`, such as min/max/mean, etc. (all scalars).
     This is used by :func:`variable_summaries`.
 
-    :param tf.Tensor|tf.Variable x:
-    :param str name:
-    :return: dicth with key -> scalar info, e.g. with "%s_mean" % name -> tf.reduce_mean(x)
-    :rtype: dict[str,tf.Tensor]
+    :param x:
+    :param name:
+    :return: dict with key -> scalar info, e.g. with "%s_mean" % name -> tf.reduce_mean(x)
     """
     if x.dtype == tf.string:
         return {}
@@ -1025,7 +1026,7 @@ def setup_tf_thread_pools(num_threads=None, log_file=None, tf_session_opts=None)
 
     :param int num_threads: used for both intra and inter parallelism thread pools
     :param stream|None log_file:
-    :param dict[str] tf_session_opts:
+    :param dict[str,typing.Any] tf_session_opts:
     """
     global _setup_tf_thread_pools_called_once
     if _setup_tf_thread_pools_called_once:
@@ -1056,12 +1057,12 @@ def setup_tf_thread_pools(num_threads=None, log_file=None, tf_session_opts=None)
         session.close()
 
 
-def check_initial_tf_thread_pool_init(tf_session_opts=None):
+def check_initial_tf_thread_pool_init(tf_session_opts: Dict[str, Any] = None):
     """
     Makes sure that the TF thread pools are initialized with the requested settings.
     You probably want to call this very early.
 
-    :param dict[str]|None tf_session_opts:
+    :param tf_session_opts:
     """
     if not _setup_tf_thread_pools_called_once:
         from returnn.util.basic import try_get_caller_name
@@ -1184,7 +1185,7 @@ def print_available_devices(tf_session_opts=None, file=None):
     Note that a call to this will trigger the internal TF thread pool inits,
     so you should call :func:`setup_tf_thread_pools` first.
 
-    :param dict[str]|None tf_session_opts: if given, will init a temp Session with these opts
+    :param dict[str,typing.Any]|None tf_session_opts: if given, will init a temp Session with these opts
     :param typing.TextIO|None file: file stream for print statements, defaults to sys.stdout
     """
     if file is None:

{returnn-1.20250122.223647 → returnn-1.20250123.173545}/returnn/util/basic.py

@@ -1963,15 +1963,15 @@ def _py2_unicode_to_str_recursive(s):
         return s
 
 
-def load_json(filename=None, content=None):
+def load_json(filename: Optional[str] = None, content: Optional[str] = None) -> Dict[str, Any]:
     """
-    :param str|None filename:
-    :param str|None content:
-    :rtype: dict[str]
+    :param filename:
+    :param content:
     """
     if content:
         assert not filename
     else:
+        assert filename
         content = open(filename).read()
     import json
 

{returnn-1.20250122.223647 → returnn-1.20250123.173545/returnn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: returnn
-Version: 1.20250122.223647
+Version: 1.20250123.173545
 Summary: The RWTH extensible training framework for universal recurrent neural networks
 Home-page: https://github.com/rwth-i6/returnn/
 Author: Albert Zeyer

returnn-1.20250122.223647/_setup_info_generated.py

@@ -1,2 +0,0 @@
-version = '1.20250122.223647'
-long_version = '1.20250122.223647+git.6dd961c'