protoprimer 0.12.0.dev1__tar.gz → 0.12.0.dev2__tar.gz

{protoprimer-0.12.0.dev1 → protoprimer-0.12.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: protoprimer
-Version: 0.12.0.dev1
+Version: 0.12.0.dev2
 Summary: Escape the fragile mess of pre-venv shell scripts with a pure Python bootstrap wrapper: 🚀 ⏩ single-touch, zero-args, self-contained, no-deps, cross-platform, testable init logic using standard tools to run apps in a custom environment isolated per repository
 Author-email: uvsmtid <uvsmtid@gmail.com>
 License: MIT

{protoprimer-0.12.0.dev1 → protoprimer-0.12.0.dev2}/main/protoprimer/primer_kernel.py

@@ -52,7 +52,7 @@ from typing import (
 
 # The release process ensures that content in this file matches the version below while tagging the release commit
 # (otherwise, if the file comes from a different commit, the version is irrelevant):
-__version__ = "0.12.0.dev1"
+__version__ = "0.12.0.dev2"
 
 logger: logging.Logger = logging.getLogger()
 
@@ -67,8 +67,8 @@ def run_process(env_ctx: EnvContext) -> None:
     try:
         ensure_min_python_version()
 
-        state_sub_command_executed: bool = env_ctx.state_graph.eval_state(TargetState.target_sub_command_executed.value.name)
-        assert state_sub_command_executed
+        state_everything_executed: bool = env_ctx.state_graph.eval_state(TargetState.target_everything_executed.value.name)
+        assert state_everything_executed
         atexit.register(lambda: env_ctx.print_exit_line(0))
 
     except subprocess.CalledProcessError as subproc_error:
@@ -482,6 +482,10 @@ class ValueName(enum.Enum):
 
     value_version = "version"
 
+    value_file_basename = "file_basename"
+
+    value_version_constraints = "version_constraints"
+
 
 class PathName(enum.Enum):
 
@@ -645,6 +649,9 @@ class ConfField(enum.Enum):
 
     field_install_specs = f"{ValueName.value_install_specs.value}"
 
+    # state_version_constraints_file_basename_inited:
+    field_version_constraints_file_basename = f"{ValueName.value_version_constraints.value}_{ValueName.value_file_basename.value}"
+
     ####################################################################################################################
 
     # child of `field_project_descriptors`:
@@ -1314,8 +1321,8 @@ class ConfConstGeneral:
     relative_path_field_note: str = f"The path is relative to the `{PathName.path_ref_root.value}` dir specified in the `{ConfField.field_ref_root_dir_rel_path.value}` field."
     common_field_global_note: str = f"This field can be specified in global config (see `{ConfLeap.leap_client.name}`) but it is override-able by local environment-specific config (see `{ConfLeap.leap_env.name}`)."
     common_field_local_note: str = f"This local environment-specific field overrides the global one (see description in `{ConfLeap.leap_client.name}`)."
-    func_note_derived_based_on_common = lambda field_name: (f"This value is derived from `{field_name}` in `{ConfLeap.leap_client.name}` (override-able in `{ConfLeap.leap_env.name}`) - see description there.")
-    func_note_derived_based_on_conf_leap_field = lambda field_name, conf_leap: (f"This value is derived from `{field_name}` - see description in `{conf_leap.name}`.")
+    func_note_derived_based_on_common = lambda field_name: f"This value is derived from `{field_name}` in `{ConfLeap.leap_client.name}` (override-able in `{ConfLeap.leap_env.name}`) - see description there."
+    func_note_derived_based_on_conf_leap_field = lambda field_name, conf_leap: f"This value is derived from `{field_name}` - see description in `{conf_leap.name}`."
 
 
 class ConfConstInput:
@@ -1416,7 +1423,7 @@ class ConfConstEnv:
 
     default_install_specs = []
 
-    constraints_txt_basename = "constraints.txt"
+    default_version_constraints_file_basename = "constraints.txt"
 
     # FT_84_11_73_28.supported_python_versions.md:
     latest_known_python_version = "3.14"
@@ -1542,7 +1549,7 @@ def _create_child_argparser(parent_argparsers):
         parser_check.set_defaults(sub_command=SubCommand.command_check.value)
 
     child_argparser = CustomArgumentParser(
-        description=(f"The early [{PrimerRuntime.runtime_proto.value}] environment bootstrapper [{KeyWord.key_primer.value}]."),
+        description=f"The early [{PrimerRuntime.runtime_proto.value}] environment bootstrapper [{KeyWord.key_primer.value}].",
         parents=parent_argparsers,
         epilog=f"Version: {__version__} | {ConfConstGeneral.name_protoprimer_site_link} | {pathlib.Path(__file__).resolve()}",
     )
@@ -1942,45 +1949,58 @@ class Bootstrapper_state_default_stderr_log_handler_configured(AbstractCachingSt
 
 
 # noinspection PyPep8Naming
-@trivial_factory
-class Bootstrapper_state_args_parsed(AbstractCachingStateNode[argparse.Namespace]):
+@conditional_factory
+class Bootstrapper_state_args_parsed_func_boot_env(AbstractCachingStateNode[argparse.Namespace]):
+
+    _state_name = staticmethod(lambda: EnvState.state_args_parsed.name)
+
+    def _eval_state_once(self) -> ValueType:
+        return parse_args()
+
+
+# noinspection PyPep8Naming
+@conditional_factory
+class Bootstrapper_state_args_parsed_not_func_boot_env(AbstractCachingStateNode[argparse.Namespace]):
 
     _state_name = staticmethod(lambda: EnvState.state_args_parsed.name)
 
     def _eval_state_once(self) -> ValueType:
-        """
-        Parse the args if `EntryFunc.func_boot_env` or `EntryFunc.func_run_main`.
-        Otherwise, pretend there are no args except `SubCommand.command_start`.
-        """
         # TODO: TODO_60_63_68_81.refactor_DAG_builder.md:
         #       This step should not be executed without need to parse args.
         #       Do not fake args. Just redesign dependency. No?
-        state_args_parsed: argparse.Namespace
-        if self.env_ctx.graph_coordinates.entry_func == EntryFunc.func_boot_env or self.env_ctx.graph_coordinates.entry_func == EntryFunc.func_run_main:
-            state_args_parsed = parse_args()
-        else:
-            # Pretend there is no args except `SubCommand.command_start`:
-            state_args_parsed = parse_args([])
-            setattr(
-                state_args_parsed,
-                ParsedArg.name_sub_command.value,
-                SubCommand.command_start.value,
-            )
+        # Pretend there is no args except `SubCommand.command_start`:
+        state_args_parsed: argparse.Namespace = parse_args([])
+        setattr(
+            state_args_parsed,
+            ParsedArg.name_sub_command.value,
+            SubCommand.command_start.value,
+        )
         return state_args_parsed
 
 
+# noinspection PyPep8Naming
+class Factory_state_args_parsed(NodeFactory[StateStride]):
+
+    def create_state_node(self) -> StateNode[ValueType]:
+        # TODO: TODO_60_63_68_81.refactor_DAG_builder.md:
+        #       This step should not be executed without need to parse args.
+        #       Do not fake args. Just redesign dependency. No?
+        if self.env_ctx.graph_coordinates.entry_func in [
+            EntryFunc.func_boot_env,
+            EntryFunc.func_run_main,
+        ]:
+            return Bootstrapper_state_args_parsed_func_boot_env(self.env_ctx)
+        else:
+            return Bootstrapper_state_args_parsed_not_func_boot_env(self.env_ctx)
+
+
 # noinspection PyPep8Naming
 @trivial_factory
 class Bootstrapper_state_input_stderr_log_level_eval_finalized(AbstractCachingStateNode[int]):
-    """
-    There is a narrow window between the default log level is set and this state is evaluated.
-    To control the default log level, see `EnvVar.var_PROTOPRIMER_STDERR_LOG_LEVEL`.
-    """
 
     _parent_states = staticmethod(
         lambda: [
             EnvState.state_input_stderr_log_level_var_loaded.name,
-            EnvState.state_default_stderr_log_handler_configured.name,
             EnvState.state_args_parsed.name,
         ]
     )
@@ -1990,8 +2010,6 @@ class Bootstrapper_state_input_stderr_log_level_eval_finalized(AbstractCachingSt
 
         state_input_stderr_log_level_var_loaded: int = self.eval_parent_state(EnvState.state_input_stderr_log_level_var_loaded.name)
 
-        state_default_stderr_logger_configured: logging.Handler = self.eval_parent_state(EnvState.state_default_stderr_log_handler_configured.name)
-
         parsed_args = self.eval_parent_state(EnvState.state_args_parsed.name)
         stderr_log_level_quiet_count: int = getattr(
             parsed_args,
@@ -2002,9 +2020,9 @@ class Bootstrapper_state_input_stderr_log_level_eval_finalized(AbstractCachingSt
             SyntaxArg.dest_verbose,
         )
 
-        stderr_log_level_eval_finalized: int
+        state_input_stderr_log_level_eval_finalized: int
         if stderr_log_level_quiet_count == 0 and stderr_log_level_verbose_count == 0:
-            stderr_log_level_eval_finalized = state_input_stderr_log_level_var_loaded
+            state_input_stderr_log_level_eval_finalized = state_input_stderr_log_level_var_loaded
         else:
             # FT_38_73_38_52.log_verbosity.md
             # The base is the numeric value of `ConfConstInput.default_PROTOPRIMER_STDERR_LOG_LEVEL`.
@@ -2015,37 +2033,50 @@ class Bootstrapper_state_input_stderr_log_level_eval_finalized(AbstractCachingSt
 
             relative_log_level = 10 * (stderr_log_level_quiet_count - stderr_log_level_verbose_count)
 
-            stderr_log_level_eval_finalized = base_log_level + relative_log_level
+            state_input_stderr_log_level_eval_finalized = base_log_level + relative_log_level
 
-            if stderr_log_level_eval_finalized < logging.NOTSET:
-                stderr_log_level_eval_finalized = logging.NOTSET
+            if state_input_stderr_log_level_eval_finalized < logging.NOTSET:
+                state_input_stderr_log_level_eval_finalized = logging.NOTSET
+
+        return state_input_stderr_log_level_eval_finalized
 
-        # TODO: TODO_60_63_68_81.refactor_DAG_builder.md:
-        #       Evaluate `stderr_log_level_eval_finalized`
-        #       but do not configure anything for `start_app` and `lib_call`
 
-        state_default_stderr_logger_configured.setLevel(stderr_log_level_eval_finalized)
+# noinspection PyPep8Naming
+@trivial_factory
+class Bootstrapper_state_input_stderr_log_level_handler_configured(AbstractCachingStateNode[logging.Handler]):
+    """
+    There is a narrow window between the default log level is set and this state is evaluated.
+    To control the default log level, see `EnvVar.var_PROTOPRIMER_STDERR_LOG_LEVEL`.
+    """
+
+    _parent_states = staticmethod(
+        lambda: [
+            EnvState.state_default_stderr_log_handler_configured.name,
+            EnvState.state_input_stderr_log_level_eval_finalized.name,
+        ]
+    )
+    _state_name = staticmethod(lambda: EnvState.state_input_stderr_log_level_handler_configured.name)
+
+    def _eval_state_once(self) -> ValueType:
+
+        state_default_stderr_logger_configured: logging.Handler = self.eval_parent_state(EnvState.state_default_stderr_log_handler_configured.name)
+
+        state_input_stderr_log_level_eval_finalized: int = self.eval_parent_state(EnvState.state_input_stderr_log_level_eval_finalized.name)
+
+        state_default_stderr_logger_configured.setLevel(state_input_stderr_log_level_eval_finalized)
         assert isinstance(
             state_default_stderr_logger_configured.formatter,
             _PrimerStderrLogFormatter,
         )
-        state_default_stderr_logger_configured.formatter.set_verbosity_level(stderr_log_level_eval_finalized)
-
-        # Set default log level for subsequent invocations:
-        level_var_value: str = logging.getLevelName(stderr_log_level_eval_finalized)
-        assert isinstance(level_var_value, str)
-        if " " in level_var_value:
-            # Due to some hacks in the `python` `logging` library,
-            # it may return non-existing level names - use number instead:
-            level_var_value = str(stderr_log_level_eval_finalized)
+        state_default_stderr_logger_configured.formatter.set_verbosity_level(state_input_stderr_log_level_eval_finalized)
 
         # Remove stack trace for levels >= WARNING (it will only print the exception itself):
-        if stderr_log_level_eval_finalized >= logging.WARNING:
+        if state_input_stderr_log_level_eval_finalized >= logging.WARNING:
             # Avoid changing that in tests - it changes the global state and causes many tests to fail unexpectedly:
             if not is_test_run():
                 sys.tracebacklimit = 0
 
-        return stderr_log_level_eval_finalized
+        return state_default_stderr_logger_configured
 
 
 # noinspection PyPep8Naming
@@ -2074,13 +2105,12 @@ class Bootstrapper_state_input_sub_command_arg_loaded(AbstractCachingStateNode[S
 
 
 # noinspection PyPep8Naming
-@trivial_factory
-class Bootstrapper_state_input_final_state_eval_finalized(AbstractCachingStateNode[str]):
+@conditional_factory
+class Bootstrapper_state_input_final_state_eval_finalized_func_boot_env(AbstractCachingStateNode[str]):
 
     _parent_states = staticmethod(
         lambda: [
             EnvState.state_args_parsed.name,
-            EnvState.state_input_sub_command_arg_loaded.name,
         ]
     )
     _state_name = staticmethod(lambda: EnvState.state_input_final_state_eval_finalized.name)
@@ -2088,8 +2118,6 @@ class Bootstrapper_state_input_final_state_eval_finalized(AbstractCachingStateNo
     def _eval_state_once(self) -> ValueType:
         state_args_parsed: argparse.Namespace = self.eval_parent_state(EnvState.state_args_parsed.name)
 
-        state_input_sub_command_arg_loaded: SubCommand = self.eval_parent_state(EnvState.state_input_sub_command_arg_loaded.name)
-
         state_input_final_state_eval_finalized: str | None
         state_input_final_state_eval_finalized = getattr(
             state_args_parsed,
@@ -2107,33 +2135,55 @@ class Bootstrapper_state_input_final_state_eval_finalized(AbstractCachingStateNo
         return state_input_final_state_eval_finalized
 
 
+# noinspection PyPep8Naming
+@conditional_factory
+class Bootstrapper_state_input_final_state_eval_finalized_not_func_boot_env(AbstractCachingStateNode[str]):
+
+    _parent_states = staticmethod(lambda: [])
+    _state_name = staticmethod(lambda: EnvState.state_input_final_state_eval_finalized.name)
+
+    def _eval_state_once(self) -> ValueType:
+        state_input_final_state_eval_finalized = self.env_ctx.final_state
+        return state_input_final_state_eval_finalized
+
+
+# noinspection PyPep8Naming
+class Factory_state_input_final_state_eval_finalized(NodeFactory[StateStride]):
+
+    def create_state_node(self) -> StateNode[ValueType]:
+        if self.env_ctx.graph_coordinates.entry_func in [
+            EntryFunc.func_boot_env,
+            EntryFunc.func_run_main,
+        ]:
+            return Bootstrapper_state_input_final_state_eval_finalized_func_boot_env(self.env_ctx)
+        else:
+            return Bootstrapper_state_input_final_state_eval_finalized_not_func_boot_env(self.env_ctx)
+
+
 # noinspection PyPep8Naming
 @trivial_factory
-class Bootstrapper_state_sub_command_executed(AbstractCachingStateNode[bool]):
+class Bootstrapper_state_func_boot_env_executed(AbstractCachingStateNode[bool]):
     """
-    This is a special node - it traverses ALL nodes.
+    This is a special node - it traverses ALL nodes for `EntryFunc` cases with parsed args.
 
-    BUT: It does not depend on ALL nodes - instead, it uses a sub command strategy implementation.
+    BUT: It does not depend on ALL nodes - instead, re-executes the graph with a new target.
     """
 
     _parent_states = staticmethod(
         lambda: [
-            EnvState.state_input_stderr_log_level_eval_finalized.name,
+            EnvState.state_input_stderr_log_level_handler_configured.name,
             EnvState.state_input_sub_command_arg_loaded.name,
             EnvState.state_input_final_state_eval_finalized.name,
         ]
     )
-    _state_name = staticmethod(lambda: EnvState.state_sub_command_executed.name)
+    _state_name = staticmethod(lambda: EnvState.state_func_boot_env_executed.name)
 
     def _eval_state_once(self) -> ValueType:
 
-        state_input_stderr_log_level_eval_finalized = self.eval_parent_state(EnvState.state_input_stderr_log_level_eval_finalized.name)
-        assert state_input_stderr_log_level_eval_finalized >= 0
+        state_input_sub_command_arg_loaded: SubCommand = self.eval_parent_state(EnvState.state_input_sub_command_arg_loaded.name)
 
         state_input_final_state_eval_finalized: str = self.eval_parent_state(EnvState.state_input_final_state_eval_finalized.name)
 
-        state_input_sub_command_arg_loaded: SubCommand = self.eval_parent_state(EnvState.state_input_sub_command_arg_loaded.name)
-
         state_node: StateNode = self.env_ctx.state_graph.get_state_node(state_input_final_state_eval_finalized)
 
         selected_strategy: RunStrategy
@@ -2156,6 +2206,111 @@ class Bootstrapper_state_sub_command_executed(AbstractCachingStateNode[bool]):
         return True
 
 
+# noinspection PyPep8Naming
+@trivial_factory
+class Bootstrapper_state_func_start_app_executed(AbstractCachingStateNode[bool]):
+
+    _parent_states = staticmethod(
+        lambda: [
+            EnvState.state_input_stderr_log_level_handler_configured.name,
+            EnvState.state_input_final_state_eval_finalized.name,
+        ]
+    )
+    _state_name = staticmethod(lambda: EnvState.state_func_start_app_executed.name)
+
+    def _eval_state_once(self) -> ValueType:
+        state_input_final_state_eval_finalized: str = self.eval_parent_state(EnvState.state_input_final_state_eval_finalized.name)
+        state_node: StateNode = self.env_ctx.state_graph.get_state_node(state_input_final_state_eval_finalized)
+        state_node.eval_own_state()
+        return True
+
+
+# noinspection PyPep8Naming
+@trivial_factory
+class Bootstrapper_state_func_call_lib_executed(AbstractCachingStateNode[bool]):
+
+    _parent_states = staticmethod(
+        lambda: [
+            EnvState.state_input_final_state_eval_finalized.name,
+        ]
+    )
+    _state_name = staticmethod(lambda: EnvState.state_func_call_lib_executed.name)
+
+    def _eval_state_once(self) -> ValueType:
+        state_input_final_state_eval_finalized: str = self.eval_parent_state(EnvState.state_input_final_state_eval_finalized.name)
+        state_node: StateNode = self.env_ctx.state_graph.get_state_node(state_input_final_state_eval_finalized)
+        state_node.eval_own_state()
+        return True
+
+
+# noinspection PyPep8Naming
+@conditional_factory
+class Bootstrapper_state_everything_executed_func_boot_env(AbstractCachingStateNode[bool]):
+
+    _parent_states = staticmethod(
+        lambda: [
+            EnvState.state_func_boot_env_executed.name,
+        ]
+    )
+    _state_name = staticmethod(lambda: EnvState.state_everything_executed.name)
+
+    def _eval_state_once(self) -> ValueType:
+        state_func_boot_env_executed: bool = self.eval_parent_state(EnvState.state_func_boot_env_executed.name)
+        return state_func_boot_env_executed
+
+
+# noinspection PyPep8Naming
+@conditional_factory
+class Bootstrapper_state_everything_executed_func_start_app(AbstractCachingStateNode[bool]):
+
+    _parent_states = staticmethod(
+        lambda: [
+            EnvState.state_func_start_app_executed.name,
+        ]
+    )
+    _state_name = staticmethod(lambda: EnvState.state_everything_executed.name)
+
+    def _eval_state_once(self) -> ValueType:
+        state_func_start_app_executed: bool = self.eval_parent_state(EnvState.state_func_start_app_executed.name)
+        return state_func_start_app_executed
+
+
+# noinspection PyPep8Naming
+@conditional_factory
+class Bootstrapper_state_everything_executed_func_call_lib(AbstractCachingStateNode[bool]):
+
+    _parent_states = staticmethod(
+        lambda: [
+            EnvState.state_func_call_lib_executed.name,
+        ]
+    )
+    _state_name = staticmethod(lambda: EnvState.state_everything_executed.name)
+
+    def _eval_state_once(self) -> ValueType:
+        state_func_call_lib_executed: bool = self.eval_parent_state(EnvState.state_func_call_lib_executed.name)
+        return state_func_call_lib_executed
+
+
+# noinspection PyPep8Naming
+class Factory_state_everything_executed(NodeFactory[StateStride]):
+    """
+    This is a special node - it traverses ALL nodes.
+    """
+
+    def create_state_node(self) -> StateNode[ValueType]:
+        if self.env_ctx.graph_coordinates.entry_func in [
+            EntryFunc.func_boot_env,
+            EntryFunc.func_run_main,
+        ]:
+            return Bootstrapper_state_everything_executed_func_boot_env(self.env_ctx)
+        elif self.env_ctx.graph_coordinates.entry_func == EntryFunc.func_start_app:
+            return Bootstrapper_state_everything_executed_func_start_app(self.env_ctx)
+        elif self.env_ctx.graph_coordinates.entry_func == EntryFunc.func_call_lib:
+            return Bootstrapper_state_everything_executed_func_call_lib(self.env_ctx)
+        else:
+            raise RuntimeError(self.env_ctx.graph_coordinates.entry_func)
+
+
 # noinspection PyPep8Naming
 @trivial_factory
 class Bootstrapper_state_input_start_id_var_loaded(AbstractCachingStateNode[str]):
@@ -2280,7 +2435,6 @@ class Bootstrapper_state_proto_code_file_abs_path_inited_func_call_lib(AbstractC
 class Bootstrapper_state_proto_code_file_abs_path_inited_not_func_call_lib(AbstractCachingStateNode[str]):
     _parent_states = staticmethod(
         lambda: [
-            EnvState.state_input_sub_command_arg_loaded.name,
             EnvState.state_input_proto_code_file_abs_path_var_loaded.name,
             EnvState.state_stride_py_arbitrary_reached.name,
         ]
@@ -2289,10 +2443,6 @@ class Bootstrapper_state_proto_code_file_abs_path_inited_not_func_call_lib(Abstr
 
     def _eval_state_once(self) -> ValueType:
 
-        state_stride_py_arbitrary_reached: StateStride = self.eval_parent_state(EnvState.state_stride_py_arbitrary_reached.name)
-
-        state_input_sub_command_arg_loaded: SubCommand = self.eval_parent_state(EnvState.state_input_sub_command_arg_loaded.name)
-
         state_input_proto_code_file_abs_path_var_loaded: str | None = self.eval_parent_state(EnvState.state_input_proto_code_file_abs_path_var_loaded.name)
 
         assert self.env_ctx.get_stride().value >= StateStride.stride_py_arbitrary.value
@@ -2306,7 +2456,10 @@ class Bootstrapper_state_proto_code_file_abs_path_inited_not_func_call_lib(Abstr
         else:
             log_python_context()
             if os.environ.get(EnvVar.var_PROTOPRIMER_MOCKED_RESTART.value, None) is None:
-                if state_input_sub_command_arg_loaded != SubCommand.command_start:
+                if self.env_ctx.graph_coordinates.entry_func in [
+                    EntryFunc.func_boot_env,
+                    EntryFunc.func_run_main,
+                ]:
                     if self.env_ctx.get_stride().value == StateStride.stride_py_arbitrary.value:
                         state_proto_code_file_abs_path_inited = os.path.abspath(__file__)
                     else:
@@ -2324,7 +2477,7 @@ class Bootstrapper_state_proto_code_file_abs_path_inited_not_func_call_lib(Abstr
                                 if is_venv():
                                     logger.warning(f"`sys.executable` [{sys.executable}] for [{StateStride.stride_py_required.name}] evaluated from config should ideally be outside `venv`")
                 else:
-                    # `SubCommand.command_start` relies only on the `EnvVar.var_PROTOPRIMER_PROTO_CODE` env var:
+                    # Rely only on the `EnvVar.var_PROTOPRIMER_PROTO_CODE` env var:
                     assert state_input_proto_code_file_abs_path_var_loaded is not None
                     state_proto_code_file_abs_path_inited = state_input_proto_code_file_abs_path_var_loaded
             else:
@@ -2402,8 +2555,6 @@ class Bootstrapper_state_primer_conf_file_data_loaded(AbstractCachingStateNode[d
 
     _parent_states = staticmethod(
         lambda: [
-            EnvState.state_input_stderr_log_level_eval_finalized.name,
-            EnvState.state_input_sub_command_arg_loaded.name,
             EnvState.state_proto_code_file_abs_path_inited.name,
             EnvState.state_primer_conf_file_abs_path_inited.name,
         ]
@@ -2564,8 +2715,6 @@ class Bootstrapper_state_client_conf_file_data_loaded(AbstractCachingStateNode[d
 
     _parent_states = staticmethod(
         lambda: [
-            EnvState.state_input_stderr_log_level_eval_finalized.name,
-            EnvState.state_input_sub_command_arg_loaded.name,
             EnvState.state_global_conf_file_abs_path_inited.name,
         ]
     )
@@ -2600,17 +2749,8 @@ class Bootstrapper_state_client_conf_file_data_loaded(AbstractCachingStateNode[d
 
 
 # noinspection PyPep8Naming
-@trivial_factory
-class Bootstrapper_state_selected_env_dir_rel_path_inited(AbstractCachingStateNode[str]):
-
-    _parent_states = staticmethod(
-        lambda: [
-            EnvState.state_args_parsed.name,
-            EnvState.state_ref_root_dir_abs_path_inited.name,
-            EnvState.state_client_conf_file_data_loaded.name,
-        ]
-    )
-    _state_name = staticmethod(lambda: EnvState.state_selected_env_dir_rel_path_inited.name)
+@conditional_factory
+class Base_state_selected_env_dir_rel_path(AbstractCachingStateNode[str]):
 
     def _eval_state_once(self) -> ValueType:
 
@@ -2641,14 +2781,11 @@ class Bootstrapper_state_selected_env_dir_rel_path_inited(AbstractCachingStateNo
 
         return state_selected_env_dir_rel_path_inited
 
+    def _select_env_conf_dir_any_path(self) -> str | None:
+        raise NotImplementedError()
+
     def _select_client_local_env_dir_any_path(self) -> str | None:
-        state_args_parsed: argparse.Namespace = self.eval_parent_state(EnvState.state_args_parsed.name)
-        env_conf_dir_any_path: str | None = getattr(
-            state_args_parsed,
-            ParsedArg.name_selected_env_dir.value,
-            # NOTE: The value is only set for `SubCommand.command_boot`, otherwise, this default is used:
-            None,
-        )
+        env_conf_dir_any_path = self._select_env_conf_dir_any_path()
         if env_conf_dir_any_path is None:
             # Use the default env configured:
             state_client_conf_file_data_loaded: dict = self.eval_parent_state(EnvState.state_client_conf_file_data_loaded.name)
@@ -2696,13 +2833,68 @@ class Bootstrapper_state_selected_env_dir_rel_path_inited(AbstractCachingStateNo
             raise AssertionError(f"`{PathName.path_selected_env.value}` [{client_local_env_dir_any_path}] is relative to neither `{PathName.path_ref_root.value}` [{state_ref_root_dir_abs_path_inited}] nor curr dir [{os.getcwd()}].")
 
 
+# noinspection PyPep8Naming
+@conditional_factory
+class Bootstrapper_state_selected_env_dir_rel_path_inited_func_boot_env(Base_state_selected_env_dir_rel_path):
+
+    _parent_states = staticmethod(
+        lambda: [
+            EnvState.state_args_parsed.name,
+            EnvState.state_ref_root_dir_abs_path_inited.name,
+            EnvState.state_client_conf_file_data_loaded.name,
+        ]
+    )
+    _state_name = staticmethod(lambda: EnvState.state_selected_env_dir_rel_path_inited.name)
+
+    def _select_env_conf_dir_any_path(self) -> str | None:
+        state_args_parsed: argparse.Namespace = self.eval_parent_state(EnvState.state_args_parsed.name)
+        env_conf_dir_any_path: str | None = getattr(
+            state_args_parsed,
+            ParsedArg.name_selected_env_dir.value,
+            # NOTE: The value is only set for `SubCommand.command_boot`, otherwise, this default is used:
+            None,
+        )
+        return env_conf_dir_any_path
+
+
+# noinspection PyPep8Naming
+@conditional_factory
+class Bootstrapper_state_selected_env_dir_rel_path_inited_not_func_boot_env(Base_state_selected_env_dir_rel_path):
+
+    _parent_states = staticmethod(
+        lambda: [
+            EnvState.state_ref_root_dir_abs_path_inited.name,
+            EnvState.state_client_conf_file_data_loaded.name,
+        ]
+    )
+    _state_name = staticmethod(lambda: EnvState.state_selected_env_dir_rel_path_inited.name)
+
+    def _select_env_conf_dir_any_path(self) -> str | None:
+        return None
+
+
+# noinspection PyPep8Naming
+class Factory_state_selected_env_dir_rel_path_inited(NodeFactory[StateStride]):
+    """
+    This is a special node - it traverses ALL nodes.
+    """
+
+    def create_state_node(self) -> StateNode[ValueType]:
+        if self.env_ctx.graph_coordinates.entry_func in [
+            EntryFunc.func_boot_env,
+            EntryFunc.func_run_main,
+        ]:
+            return Bootstrapper_state_selected_env_dir_rel_path_inited_func_boot_env(self.env_ctx)
+        else:
+            return Bootstrapper_state_selected_env_dir_rel_path_inited_not_func_boot_env(self.env_ctx)
+
+
 # noinspection PyPep8Naming
 @trivial_factory
 class Bootstrapper_state_local_conf_symlink_abs_path_inited(AbstractCachingStateNode[str]):
 
     _parent_states = staticmethod(
         lambda: [
-            EnvState.state_input_sub_command_arg_loaded.name,
             EnvState.state_ref_root_dir_abs_path_inited.name,
             EnvState.state_client_conf_file_data_loaded.name,
             EnvState.state_selected_env_dir_rel_path_inited.name,
@@ -2712,8 +2904,6 @@ class Bootstrapper_state_local_conf_symlink_abs_path_inited(AbstractCachingState
 
     def _eval_state_once(self) -> ValueType:
 
-        state_input_sub_command_arg_loaded: SubCommand = self.eval_parent_state(EnvState.state_input_sub_command_arg_loaded.name)
-
         state_ref_root_dir_abs_path_inited: str = self.eval_parent_state(EnvState.state_ref_root_dir_abs_path_inited.name)
 
         state_selected_env_dir_rel_path_inited: str | None = self.eval_parent_state(EnvState.state_selected_env_dir_rel_path_inited.name)
@@ -2743,7 +2933,10 @@ class Bootstrapper_state_local_conf_symlink_abs_path_inited(AbstractCachingState
         if os.path.exists(state_local_conf_symlink_abs_path_inited):
             if os.path.islink(state_local_conf_symlink_abs_path_inited):
                 if os.path.isdir(state_local_conf_symlink_abs_path_inited):
-                    if state_input_sub_command_arg_loaded == SubCommand.command_start:
+                    if self.env_ctx.graph_coordinates.entry_func in [
+                        EntryFunc.func_start_app,
+                        EntryFunc.func_call_lib,
+                    ]:
                         # Nothing to do:
                         pass
                     else:
@@ -2803,8 +2996,6 @@ class Bootstrapper_state_env_conf_file_data_loaded(AbstractCachingStateNode[dict
 
     _parent_states = staticmethod(
         lambda: [
-            EnvState.state_input_stderr_log_level_eval_finalized.name,
-            EnvState.state_input_sub_command_arg_loaded.name,
             EnvState.state_local_conf_file_abs_path_inited.name,
         ]
     )
@@ -3163,6 +3354,25 @@ class Bootstrapper_state_install_specs_inited(AbstractOverriddenFieldCachingStat
         return install_specs
 
 
+# noinspection PyPep8Naming
+@trivial_factory
+class Bootstrapper_state_version_constraints_file_basename_inited(AbstractOverriddenFieldCachingStateNode[str]):
+
+    _parent_states = staticmethod(
+        lambda: [
+            EnvState.state_client_conf_file_data_loaded.name,
+            EnvState.state_env_conf_file_data_loaded.name,
+        ]
+    )
+    _state_name = staticmethod(lambda: EnvState.state_version_constraints_file_basename_inited.name)
+
+    def _eval_state_once(self) -> ValueType:
+        return self._get_overridden_value_or_default(
+            ConfField.field_version_constraints_file_basename.value,
+            ConfConstEnv.default_version_constraints_file_basename,
+        )
+
+
 # noinspection PyPep8Naming
 @trivial_factory
 class Bootstrapper_state_derived_conf_data_loaded(AbstractCachingStateNode[dict]):
@@ -3271,7 +3481,7 @@ class Bootstrapper_state_default_file_log_handler_configured(AbstractCachingStat
     _parent_states = staticmethod(
         lambda: [
             EnvState.state_args_parsed.name,
-            EnvState.state_input_stderr_log_level_eval_finalized.name,
+            EnvState.state_input_stderr_log_level_handler_configured.name,
             EnvState.state_input_start_id_var_loaded.name,
             EnvState.state_local_log_dir_abs_path_inited.name,
         ]
@@ -3284,7 +3494,7 @@ class Bootstrapper_state_default_file_log_handler_configured(AbstractCachingStat
 
         state_local_log_dir_abs_path_inited: str = self.eval_parent_state(EnvState.state_local_log_dir_abs_path_inited.name)
 
-        state_input_stderr_log_level_eval_finalized: int = self.eval_parent_state(EnvState.state_input_stderr_log_level_eval_finalized.name)
+        state_input_stderr_log_level_handler_configured: logging.Handler = self.eval_parent_state(EnvState.state_input_stderr_log_level_handler_configured.name)
 
         script_path = sys.argv[0]
         script_name = os.path.basename(script_path)
@@ -3292,7 +3502,7 @@ class Bootstrapper_state_default_file_log_handler_configured(AbstractCachingStat
         file_handler = _configure_primer_file_log_handler(
             script_name,
             state_input_start_id_var_loaded,
-            state_input_stderr_log_level_eval_finalized,
+            state_input_stderr_log_level_handler_configured,
             state_local_log_dir_abs_path_inited,
         )
 
@@ -3330,14 +3540,6 @@ class Bootstrapper_state_stride_py_required_reached_not_command_start(AbstractCa
         if self.env_ctx.has_stride_reached(next_stride=state_stride_py_required_reached):
             return self.env_ctx.set_max_stride(state_stride_py_required_reached)
 
-        state_input_sub_command_arg_loaded: SubCommand = self.eval_parent_state(EnvState.state_input_sub_command_arg_loaded.name)
-
-        # TODO: Unused, but plugged in to form complete DAG: consider adding intermediate state to plug it in:
-        state_default_file_log_handler_configured = self.eval_parent_state(EnvState.state_default_file_log_handler_configured.name)
-
-        # TODO: Unused, but plugged in to form complete DAG: consider adding intermediate state to plug it in:
-        state_local_tmp_dir_abs_path_inited = self.eval_parent_state(EnvState.state_local_tmp_dir_abs_path_inited.name)
-
         state_input_start_id_var_loaded: str = self.eval_parent_state(EnvState.state_input_start_id_var_loaded.name)
 
         state_proto_code_file_abs_path_inited: str = self.eval_parent_state(EnvState.state_proto_code_file_abs_path_inited.name)
@@ -3425,7 +3627,7 @@ class Factory_state_stride_py_required_reached(NodeFactory[StateStride]):
 @trivial_factory
 class Bootstrapper_state_reboot_triggered(AbstractCachingStateNode[bool]):
     """
-    Removes current `venv` dir and `constraints.txt` file (to trigger their re-creation subsequently).
+    Removes current `venv` dir and `version_constraints.txt` file (to trigger their re-creation subsequently).
     """
 
     _parent_states = staticmethod(
@@ -3437,6 +3639,7 @@ class Bootstrapper_state_reboot_triggered(AbstractCachingStateNode[bool]):
             EnvState.state_local_conf_symlink_abs_path_inited.name,
             EnvState.state_local_venv_dir_abs_path_inited.name,
             EnvState.state_local_tmp_dir_abs_path_inited.name,
+            EnvState.state_version_constraints_file_basename_inited.name,
             EnvState.state_stride_py_required_reached.name,
         ]
     )
@@ -3444,8 +3647,6 @@ class Bootstrapper_state_reboot_triggered(AbstractCachingStateNode[bool]):
 
     def _eval_state_once(self) -> ValueType:
 
-        state_args_parsed: argparse.Namespace = self.eval_parent_state(EnvState.state_args_parsed.name)
-
         state_input_sub_command_arg_loaded: SubCommand = self.eval_parent_state(EnvState.state_input_sub_command_arg_loaded.name)
 
         if state_input_sub_command_arg_loaded == SubCommand.command_start:
@@ -3463,8 +3664,6 @@ class Bootstrapper_state_reboot_triggered(AbstractCachingStateNode[bool]):
         state_stride_py_required_reached: StateStride = self.eval_parent_state(EnvState.state_stride_py_required_reached.name)
         assert self.env_ctx.get_stride().value >= StateStride.stride_py_required.value
 
-        state_proto_code_file_abs_path_inited: str = self.eval_parent_state(EnvState.state_proto_code_file_abs_path_inited.name)
-
         # Reboot can only happen outside `venv` (to delete it):
         if not (reboot_env and state_stride_py_required_reached == StateStride.stride_py_required):
             return False
@@ -3489,9 +3688,10 @@ class Bootstrapper_state_reboot_triggered(AbstractCachingStateNode[bool]):
             )
 
         state_local_conf_symlink_abs_path_inited = self.eval_parent_state(EnvState.state_local_conf_symlink_abs_path_inited.name)
+        state_version_constraints_file_basename_inited: str = self.eval_parent_state(EnvState.state_version_constraints_file_basename_inited.name)
         constraints_txt_path = os.path.join(
             state_local_conf_symlink_abs_path_inited,
-            ConfConstEnv.constraints_txt_basename,
+            state_version_constraints_file_basename_inited,
         )
         if os.path.exists(constraints_txt_path):
             logger.info(f"removing version constraints file [{constraints_txt_path}]")
@@ -3597,8 +3797,6 @@ class Bootstrapper_state_stride_py_venv_reached(AbstractCachingStateNode[StateSt
 
         state_input_start_id_var_loaded: str = self.eval_parent_state(EnvState.state_input_start_id_var_loaded.name)
 
-        state_reboot_triggered: bool = self.eval_parent_state(EnvState.state_reboot_triggered.name)
-
         state_proto_code_file_abs_path_inited: str = self.eval_parent_state(EnvState.state_proto_code_file_abs_path_inited.name)
 
         state_selected_python_file_abs_path_inited: str = self.eval_parent_state(EnvState.state_selected_python_file_abs_path_inited.name)
@@ -3668,6 +3866,7 @@ class Bootstrapper_state_protoprimer_package_installed(AbstractCachingStateNode[
             EnvState.state_local_conf_symlink_abs_path_inited.name,
             EnvState.state_project_descriptors_inited.name,
             EnvState.state_install_specs_inited.name,
+            EnvState.state_version_constraints_file_basename_inited.name,
             EnvState.state_venv_driver_prepared.name,
             EnvState.state_stride_py_venv_reached.name,
         ]
@@ -3701,6 +3900,8 @@ class Bootstrapper_state_protoprimer_package_installed(AbstractCachingStateNode[
 
         state_venv_driver_prepared: VenvDriverBase = self.eval_parent_state(EnvState.state_venv_driver_prepared.name)
 
+        state_version_constraints_file_basename_inited: str = self.eval_parent_state(EnvState.state_version_constraints_file_basename_inited.name)
+
         reboot_env: bool = state_args_parsed.sub_command == SubCommand.command_reboot.value
 
         do_install: bool = (
@@ -3714,7 +3915,7 @@ class Bootstrapper_state_protoprimer_package_installed(AbstractCachingStateNode[
 
         constraints_txt_path = os.path.join(
             state_local_conf_symlink_abs_path_inited,
-            ConfConstEnv.constraints_txt_basename,
+            state_version_constraints_file_basename_inited,
         )
         if not os.path.exists(constraints_txt_path):
             logger.info(f"creating empty constraints file [{constraints_txt_path}]")
@@ -3806,6 +4007,7 @@ class Bootstrapper_state_version_constraints_generated(AbstractCachingStateNode[
         lambda: [
             EnvState.state_input_sub_command_arg_loaded.name,
             EnvState.state_local_conf_symlink_abs_path_inited.name,
+            EnvState.state_version_constraints_file_basename_inited.name,
             EnvState.state_venv_driver_prepared.name,
             EnvState.state_protoprimer_package_installed.name,
         ]
@@ -3818,7 +4020,7 @@ class Bootstrapper_state_version_constraints_generated(AbstractCachingStateNode[
 
         if state_input_sub_command_arg_loaded == SubCommand.command_start:
             # The only reason for `EnvState.state_version_constraints_generated`
-            # is to re-generate the `constraints.txt` file based on `venv`.
+            # is to re-generate the `version_constraints.txt` file based on `venv`.
             # Skip it as `venv` is supposed to be ready in `SubCommand.command_start`:
             return False
 
@@ -3831,11 +4033,13 @@ class Bootstrapper_state_version_constraints_generated(AbstractCachingStateNode[
 
         state_venv_driver_prepared: VenvDriverBase = self.eval_parent_state(EnvState.state_venv_driver_prepared.name)
 
+        state_version_constraints_file_basename_inited: str = self.eval_parent_state(EnvState.state_version_constraints_file_basename_inited.name)
+
         state_venv_driver_prepared.pin_versions(
             get_path_to_curr_python(),
             os.path.join(
                 state_local_conf_symlink_abs_path_inited,
-                ConfConstEnv.constraints_txt_basename,
+                state_version_constraints_file_basename_inited,
             ),
         )
 
@@ -3875,8 +4079,6 @@ class Bootstrapper_state_stride_deps_updated_reached(AbstractCachingStateNode[St
 
         state_proto_code_file_abs_path_inited: str = self.eval_parent_state(EnvState.state_proto_code_file_abs_path_inited.name)
 
-        state_version_constraints_generated: bool = self.eval_parent_state(EnvState.state_version_constraints_generated.name)
-
         state_local_venv_dir_abs_path_inited: str = self.eval_parent_state(EnvState.state_local_venv_dir_abs_path_inited.name)
 
         venv_path_to_python: str = os.path.join(
@@ -3915,7 +4117,6 @@ class Bootstrapper_state_proto_code_updated(AbstractCachingStateNode[bool]):
 
     def _eval_state_once(self) -> ValueType:
 
-        state_stride_deps_updated_reached: StateStride = self.eval_parent_state(EnvState.state_stride_deps_updated_reached.name)
         assert self.env_ctx.get_stride().value >= StateStride.stride_deps_updated.value
 
         if self.env_ctx.get_stride().value != StateStride.stride_deps_updated.value:
@@ -4002,15 +4203,11 @@ class Bootstrapper_state_stride_src_updated_reached(AbstractCachingStateNode[Sta
 
         state_stride_src_updated_reached: StateStride = StateStride.stride_src_updated
 
-        state_input_sub_command_arg_loaded: SubCommand = self.eval_parent_state(EnvState.state_input_sub_command_arg_loaded.name)
-
         if self.env_ctx.has_stride_reached(next_stride=state_stride_src_updated_reached):
             return self.env_ctx.set_max_stride(state_stride_src_updated_reached)
 
         state_proto_code_file_abs_path_inited: str = self.eval_parent_state(EnvState.state_proto_code_file_abs_path_inited.name)
 
-        state_proto_code_updated: bool = self.eval_parent_state(EnvState.state_proto_code_updated.name)
-
         state_local_venv_dir_abs_path_inited: str = self.eval_parent_state(EnvState.state_local_venv_dir_abs_path_inited.name)
 
         venv_path_to_python: str = os.path.join(
@@ -4101,16 +4298,24 @@ class EnvState(enum.Enum):
 
     state_default_stderr_log_handler_configured = Bootstrapper_state_default_stderr_log_handler_configured
 
-    state_args_parsed = Bootstrapper_state_args_parsed
+    state_args_parsed = Factory_state_args_parsed
 
     state_input_stderr_log_level_eval_finalized = Bootstrapper_state_input_stderr_log_level_eval_finalized
 
+    state_input_stderr_log_level_handler_configured = Bootstrapper_state_input_stderr_log_level_handler_configured
+
     state_input_sub_command_arg_loaded = Bootstrapper_state_input_sub_command_arg_loaded
 
-    state_input_final_state_eval_finalized = Bootstrapper_state_input_final_state_eval_finalized
+    state_input_final_state_eval_finalized = Factory_state_input_final_state_eval_finalized
+
+    state_func_boot_env_executed = Bootstrapper_state_func_boot_env_executed
+
+    state_func_start_app_executed = Bootstrapper_state_func_start_app_executed
+
+    state_func_call_lib_executed = Bootstrapper_state_func_call_lib_executed
 
     # Special case: triggers everything:
-    state_sub_command_executed = Bootstrapper_state_sub_command_executed
+    state_everything_executed = Factory_state_everything_executed
 
     state_input_start_id_var_loaded = Bootstrapper_state_input_start_id_var_loaded
 
@@ -4135,7 +4340,7 @@ class EnvState(enum.Enum):
     # `ConfLeap.leap_client`:
     state_client_conf_file_data_loaded = Bootstrapper_state_client_conf_file_data_loaded
 
-    state_selected_env_dir_rel_path_inited = Bootstrapper_state_selected_env_dir_rel_path_inited
+    state_selected_env_dir_rel_path_inited = Factory_state_selected_env_dir_rel_path_inited
 
     state_local_conf_symlink_abs_path_inited = Bootstrapper_state_local_conf_symlink_abs_path_inited
 
@@ -4169,6 +4374,8 @@ class EnvState(enum.Enum):
 
     state_install_specs_inited = Bootstrapper_state_install_specs_inited
 
+    state_version_constraints_file_basename_inited = Bootstrapper_state_version_constraints_file_basename_inited
+
     # `ConfLeap.leap_derived`:
     state_derived_conf_data_loaded = Bootstrapper_state_derived_conf_data_loaded
 
@@ -4209,11 +4416,8 @@ class TargetState(enum.Enum):
     Special `EnvState`-s.
     """
 
-    # Used for `EnvState.state_status_line_printed` to report exit code:
-    target_stderr_log_handler = EnvState.state_default_stderr_log_handler_configured
-
-    # A special state that triggers execution of the specific `SubCommand`:
-    target_sub_command_executed = EnvState.state_sub_command_executed
+    # A special state that triggers execution of everything else:
+    target_everything_executed = EnvState.state_everything_executed
 
     # FT_00_22_19_59.derived_config.md:
     target_derived_config_loaded = EnvState.state_derived_conf_data_loaded
@@ -4329,14 +4533,13 @@ class MutableValue(Generic[ValueType]):
 
     def set_curr_value(
         self,
-        state_node: StateNode | None,
+        state_node: StateNode,
         curr_value: ValueType,
     ) -> None:
         # TODO: Shell we also ensure that the `StateNode` using that `MutableValue` has necessary dependencies on write?
 
         if self.curr_value is None:
             raise AssertionError(f"`{MutableValue.__name__}` [{self.state_name}] cannot be set as it is not initialized yet.")
-        state_name: str | None = None
         self.curr_value = curr_value
         logger.debug(f"`{self.__class__.__name__}` [{self.state_name}] `curr_value` after set [{self.curr_value}] in [{state_node.get_state_name()}]")
 
@@ -4614,40 +4817,53 @@ class _PrimerStderrLogFormatter(DefaultStderrLogFormatter):
         }
 
 
+def _reconfigure_log_handler(
+    formatter_class: type,
+    new_formatter: logging.Formatter,
+    log_level: int,
+) -> logging.Handler | None:
+    for log_handler in logger.handlers:
+        if isinstance(log_handler.formatter, formatter_class):
+            # This covers both `_Primer*` (subclass) and `Default*` formatter variants.
+            log_handler.setFormatter(new_formatter)
+            log_handler.setLevel(log_level)
+            # Remove `protoprimer`-specific filter if present:
+            for handler_filter in list(log_handler.filters):
+                if isinstance(handler_filter, StateStrideFilter):
+                    log_handler.removeFilter(handler_filter)
+            return log_handler
+    return None
+
+
 def reconfigure_stderr_log_handler(log_level: int = logging.WARNING) -> logging.Handler | None:
     """
     UC_81_50_97_17.reuse_logger.md
     """
-
     logger.setLevel(logging.NOTSET)
+    return _reconfigure_log_handler(
+        formatter_class=DefaultStderrLogFormatter,
+        new_formatter=DefaultStderrLogFormatter(log_level),
+        log_level=log_level,
+    )
 
-    # Check for existing primer handler (to replace its formatter):
-    stderr_handler: logging.Handler
-    for stderr_handler in logger.handlers:
-        if isinstance(stderr_handler, logging.StreamHandler) and stderr_handler.stream is sys.stderr and isinstance(stderr_handler.formatter, DefaultStderrLogFormatter):
-            # This covers both `_PrimerStderrLogFormatter` (subclass) and `DefaultStderrLogFormatter`.
-            stderr_handler.setFormatter(DefaultStderrLogFormatter(log_level))
-            stderr_handler.setLevel(log_level)
-
-            # Remove primer-specific filter if present:
-            for f in list(stderr_handler.filters):
-                if isinstance(f, StateStrideFilter):
-                    stderr_handler.removeFilter(f)
-
-            return stderr_handler
 
+def _find_existing_log_handler(
+    handler_class: type[logging.StreamHandler],
+    formatter_class: type,
+) -> logging.StreamHandler | None:
+    """
+    Prevent duplicate handler (when `os.execv*` calls restart `main` again in tests).
+    """
+    if os.environ.get(EnvVar.var_PROTOPRIMER_MOCKED_RESTART.value, None) is None:
+        return None
+    log_handler: logging.Handler
+    for log_handler in logger.handlers:
+        if isinstance(log_handler, handler_class):
+            if isinstance(log_handler.formatter, formatter_class):
+                return log_handler
     return None
 
 
-def configure_default_stderr_log_handler(log_level: int = logging.WARNING) -> logging.Handler:
-    logger.setLevel(logging.NOTSET)
-    stderr_handler: logging.Handler = logging.StreamHandler(sys.stderr)
-    stderr_handler.setFormatter(DefaultStderrLogFormatter(log_level))
-    stderr_handler.setLevel(log_level)
-    logger.addHandler(stderr_handler)
-    return stderr_handler
-
-
 def _configure_primer_stderr_log_handler(state_input_stderr_log_level_var_loaded: int) -> logging.Handler:
     """
     Implements for `stderr` log: FT_38_73_38_52.log_verbosity.md
@@ -4656,23 +4872,16 @@ def _configure_primer_stderr_log_handler(state_input_stderr_log_level_var_loaded
     # Log everything (the filters are supposed to be set on output handlers instead):
     logger.setLevel(logging.NOTSET)
 
-    handler_class = logging.StreamHandler
-    stderr_handler: logging.Handler | None = None
-    if os.environ.get(EnvVar.var_PROTOPRIMER_MOCKED_RESTART.value, None) is not None:
-        # Prevent duplicate handler (when `os.execv*` calls restart `main` again in tests).
-        # Select `stderr` handler:
-        for handler_instance in logger.handlers:
-            if isinstance(handler_instance, handler_class):
-                if handler_instance.stream is sys.stderr:
-                    stderr_handler = handler_instance
-                    break
+    stderr_handler: logging.StreamHandler | None = _find_existing_log_handler(
+        logging.StreamHandler,
+        _PrimerStderrLogFormatter,
+    )
 
     if stderr_handler is None:
-        stderr_handler: logging.Handler = handler_class(sys.stderr)
-
+        stderr_handler = logging.StreamHandler(sys.stderr)
+        assert stderr_handler is not None
         stderr_handler.addFilter(StateStrideFilter())
         stderr_handler.setFormatter(_PrimerStderrLogFormatter(state_input_stderr_log_level_var_loaded))
-
         logger.addHandler(stderr_handler)
 
     stderr_handler.setLevel(state_input_stderr_log_level_var_loaded)
@@ -4683,41 +4892,17 @@ def reconfigure_file_log_handler(log_level: int = logging.INFO) -> logging.Handl
     """
     UC_81_50_97_17.reuse_logger.md
     """
-
-    # Check for existing `_Primer*` handler (to replace its formatter):
-    file_handler: logging.Handler
-    for file_handler in logger.handlers:
-        if isinstance(file_handler, logging.FileHandler) and isinstance(file_handler.formatter, DefaultFileLogFormatter):
-            # This covers both `_PrimerFileLogFormatter` (subclass) and `DefaultFileLogFormatter`.
-            file_handler.setFormatter(DefaultFileLogFormatter())
-            file_handler.setLevel(log_level)
-
-            # Remove primer-specific filter if present:
-            for handler_filter in list(file_handler.filters):
-                if isinstance(handler_filter, StateStrideFilter):
-                    file_handler.removeFilter(handler_filter)
-
-            return file_handler
-
-    return None
-
-
-def configure_default_file_log_handler(
-    log_file_abs_path: str,
-    log_level: int = logging.INFO,
-) -> logging.Handler:
-    os.makedirs(os.path.dirname(log_file_abs_path), exist_ok=True)
-    file_handler: logging.Handler = logging.FileHandler(log_file_abs_path)
-    file_handler.setFormatter(DefaultFileLogFormatter())
-    file_handler.setLevel(log_level)
-    logger.addHandler(file_handler)
-    return file_handler
+    return _reconfigure_log_handler(
+        formatter_class=DefaultFileLogFormatter,
+        new_formatter=DefaultFileLogFormatter(),
+        log_level=log_level,
+    )
 
 
 def _configure_primer_file_log_handler(
     script_name: str,
     state_input_start_id_var_loaded: str,
-    state_input_stderr_log_level_eval_finalized: int,
+    state_input_stderr_log_level_handler_configured: logging.Handler,
     state_local_log_dir_abs_path_inited: str,
 ) -> logging.Handler:
     """
@@ -4733,33 +4918,37 @@ def _configure_primer_file_log_handler(
     # TODO: Configure MAX file log level in the config file (NOTE: the higher the level the fewer the log entries):
     file_log_level: int = logging.INFO
     # Increase the log level at most to what is used by stderr:
-    if state_input_stderr_log_level_eval_finalized < file_log_level:
-        file_log_level = state_input_stderr_log_level_eval_finalized
+    if state_input_stderr_log_level_handler_configured.level < file_log_level:
+        file_log_level = state_input_stderr_log_level_handler_configured.level
 
-    os.makedirs(
-        state_local_log_dir_abs_path_inited,
-        exist_ok=True,
+    file_handler: logging.StreamHandler | None = _find_existing_log_handler(
+        logging.FileHandler,
+        _PrimerFileLogFormatter,
     )
 
-    if not os.path.exists(log_file_abs_path):
-        # Explain missing logs to avoid confusion:
-        write_text_file(
-            log_file_abs_path,
-            f"""
+    if file_handler is None:
+        os.makedirs(
+            state_local_log_dir_abs_path_inited,
+            exist_ok=True,
+        )
+
+        if not os.path.exists(log_file_abs_path):
+            # Explain missing logs to avoid confusion:
+            write_text_file(
+                log_file_abs_path,
+                f"""
 {ConfConstGeneral.log_section_delimiter} file log starts at [{StateStride.stride_py_arbitrary.name}] after its config is resolved {ConfConstGeneral.log_section_delimiter}
 
 """,
-        )
-
-    file_handler: logging.Handler = logging.FileHandler(log_file_abs_path)
-    file_handler.addFilter(StateStrideFilter())
+            )
 
-    file_formatter = _PrimerFileLogFormatter()
+        file_handler = logging.FileHandler(log_file_abs_path)
+        assert file_handler is not None
+        file_handler.addFilter(StateStrideFilter())
+        file_handler.setFormatter(_PrimerFileLogFormatter())
+        logger.addHandler(file_handler)
 
     file_handler.setLevel(file_log_level)
-    file_handler.setFormatter(file_formatter)
-
-    logger.addHandler(file_handler)
     return file_handler
 
 
@@ -5197,7 +5386,7 @@ def select_python_file_abs_path(
         try:
             logger.debug(f"trying `python` version of `selected_python_abs_path` [{selected_python_abs_path}]")
             python_version: tuple[int, int, int] = get_python_version(selected_python_abs_path)
-            logger.info(f"`python` version of `selected_python_abs_path` [{selected_python_abs_path}] is [{python_version}]")
+            logger.debug(f"`python` version of `selected_python_abs_path` [{selected_python_abs_path}] is [{python_version}]")
         except (subprocess.CalledProcessError, FileNotFoundError):
             logger.warning(f"`python` in `selected_python_abs_path` [{selected_python_abs_path}] failed without returning its version")
             selected_python_abs_path = None

{protoprimer-0.12.0.dev1 → protoprimer-0.12.0.dev2}/main/protoprimer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: protoprimer
-Version: 0.12.0.dev1
+Version: 0.12.0.dev2
 Summary: Escape the fragile mess of pre-venv shell scripts with a pure Python bootstrap wrapper: 🚀 ⏩ single-touch, zero-args, self-contained, no-deps, cross-platform, testable init logic using standard tools to run apps in a custom environment isolated per repository
 Author-email: uvsmtid <uvsmtid@gmail.com>
 License: MIT

{protoprimer-0.12.0.dev1 → protoprimer-0.12.0.dev2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "protoprimer"
-version = "0.12.0.dev1"
+version = "0.12.0.dev2"
 
 authors = [
     { name = "uvsmtid", email = "uvsmtid@gmail.com" },